blob: 79440fdf87e2d712f64bc7c5a2a4126ad61c6943 [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
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010050/* The plan here is to generate a random anonymous socket name and
51 * advertise that through a service on the session dbus.
52 */
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -050053static const char *option_socket_name = NULL;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -040054static int option_idle_time = 300;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -050055
Kristian Høgsberg27da5382011-06-21 17:32:25 -040056static struct wl_list child_process_list;
57
58static int
59sigchld_handler(int signal_number, void *data)
60{
61 struct wlsc_process *p;
62 int status;
63 pid_t pid;
64
65 pid = wait(&status);
66 wl_list_for_each(p, &child_process_list, link) {
67 if (p->pid == pid)
68 break;
69 }
70
71 if (&p->link == &child_process_list) {
72 fprintf(stderr, "unknown child process exited\n");
73 return 1;
74 }
75
76 wl_list_remove(&p->link);
77 p->cleanup(p, status);
78
79 return 1;
80}
81
82WL_EXPORT void
83wlsc_watch_process(struct wlsc_process *process)
84{
85 wl_list_insert(&child_process_list, &process->link);
86}
87
Benjamin Franzke06286262011-05-06 19:12:33 +020088static void
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020089child_client_exec(int sockfd, const char *path)
90{
91 int flags;
92 char s[32];
93
94 /* SOCK_CLOEXEC closes both ends, so we need to unset
95 * the flag on the client fd. */
96 flags = fcntl(sockfd, F_GETFD);
97 if (flags != -1)
98 fcntl(sockfd, F_SETFD, flags & ~FD_CLOEXEC);
99
100 snprintf(s, sizeof s, "%d", sockfd);
101 setenv("WAYLAND_SOCKET", s, 1);
102
103 if (execl(path, path, NULL) < 0)
104 fprintf(stderr, "compositor: executing '%s' failed: %m\n",
105 path);
106}
107
108WL_EXPORT struct wl_client *
109wlsc_client_launch(struct wlsc_compositor *compositor,
110 struct wlsc_process *proc,
111 const char *path,
112 wlsc_process_cleanup_func_t cleanup)
113{
114 int sv[2];
115 pid_t pid;
116 struct wl_client *client;
117
118 if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {
119 fprintf(stderr, "wlsc_client_launch: "
120 "socketpair failed while launching '%s': %m\n",
121 path);
122 return NULL;
123 }
124
125 pid = fork();
126 if (pid == -1) {
127 close(sv[0]);
128 close(sv[1]);
129 fprintf(stderr, "wlsc_client_launch: "
130 "fork failed while launching '%s': %m\n", path);
131 return NULL;
132 }
133
134 if (pid == 0) {
135 child_client_exec(sv[1], path);
136 exit(-1);
137 }
138
139 close(sv[1]);
140
141 client = wl_client_create(compositor->wl_display, sv[0]);
142 if (!client) {
143 close(sv[0]);
144 fprintf(stderr, "wlsc_client_launch: "
145 "wl_client_create failed while launching '%s'.\n",
146 path);
147 return NULL;
148 }
149
150 proc->pid = pid;
151 proc->cleanup = cleanup;
152 wlsc_watch_process(proc);
153
154 return client;
155}
156
157static void
Benjamin Franzke06286262011-05-06 19:12:33 +0200158surface_handle_buffer_destroy(struct wl_listener *listener,
159 struct wl_resource *resource, uint32_t time)
160{
Kristian Høgsberg24596942011-10-24 17:51:02 -0400161 struct wlsc_surface *es = container_of(listener, struct wlsc_surface,
Benjamin Franzke06286262011-05-06 19:12:33 +0200162 buffer_destroy_listener);
Benjamin Franzke06286262011-05-06 19:12:33 +0200163
Kristian Høgsberg24596942011-10-24 17:51:02 -0400164 es->buffer = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200165}
166
167static void
168output_handle_scanout_buffer_destroy(struct wl_listener *listener,
169 struct wl_resource *resource,
170 uint32_t time)
171{
172 struct wlsc_output *output =
173 container_of(listener, struct wlsc_output,
174 scanout_buffer_destroy_listener);
Benjamin Franzke06286262011-05-06 19:12:33 +0200175
Kristian Høgsberg24596942011-10-24 17:51:02 -0400176 output->scanout_buffer = NULL;
Ander Conselvan de Oliveira9a38a0a2011-10-26 16:48:45 +0300177
178 if (!output->pending_scanout_buffer)
179 wlsc_compositor_schedule_repaint(output->compositor);
Benjamin Franzke06286262011-05-06 19:12:33 +0200180}
181
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300182static void
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400183output_handle_pending_scanout_buffer_destroy(struct wl_listener *listener,
184 struct wl_resource *resource,
185 uint32_t time)
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300186{
187 struct wlsc_output *output =
188 container_of(listener, struct wlsc_output,
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400189 pending_scanout_buffer_destroy_listener);
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300190
Kristian Høgsberg24596942011-10-24 17:51:02 -0400191 output->pending_scanout_buffer = NULL;
Ander Conselvan de Oliveira9a38a0a2011-10-26 16:48:45 +0300192
193 wlsc_compositor_schedule_repaint(output->compositor);
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300194}
195
196
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400197WL_EXPORT struct wlsc_surface *
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400198wlsc_surface_create(struct wlsc_compositor *compositor,
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400199 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500200{
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400201 struct wlsc_surface *surface;
202
Pekka Paalanen56cdea92011-11-23 16:14:12 +0200203 surface = calloc(1, sizeof *surface);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400204 if (surface == NULL)
205 return NULL;
206
Kristian Høgsbergf6b14712011-01-06 15:32:14 -0500207 wl_list_init(&surface->link);
Benjamin Franzkebab41fb2011-03-07 18:04:59 +0100208 wl_list_init(&surface->buffer_link);
Kristian Høgsbergc551bd22010-12-06 16:43:16 -0500209
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500210 glGenTextures(1, &surface->texture);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400211 glBindTexture(GL_TEXTURE_2D, surface->texture);
212 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
213 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400214
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400215 surface->surface.resource.client = NULL;
Kristian Høgsberg8244b442011-06-23 15:44:14 -0400216
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500217 surface->compositor = compositor;
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400218 surface->visual = WLSC_NONE_VISUAL;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200219 surface->image = EGL_NO_IMAGE_KHR;
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200220 surface->saved_texture = 0;
Kristian Høgsberg1db21f12010-08-16 16:08:12 -0400221 surface->x = x;
222 surface->y = y;
223 surface->width = width;
224 surface->height = height;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400225
Kristian Høgsbergcbd06f92011-10-12 16:29:31 -0400226 surface->fullscreen_output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200227 surface->buffer = NULL;
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -0400228 surface->output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200229
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400230 pixman_region32_init(&surface->damage);
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400231 pixman_region32_init(&surface->opaque);
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500232 wl_list_init(&surface->frame_callback_list);
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400233
Benjamin Franzke06286262011-05-06 19:12:33 +0200234 surface->buffer_destroy_listener.func = surface_handle_buffer_destroy;
Benjamin Franzke06286262011-05-06 19:12:33 +0200235
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400236 surface->transform = NULL;
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500237
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400238 return surface;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500239}
240
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400241WL_EXPORT void
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500242wlsc_surface_damage_rectangle(struct wlsc_surface *surface,
243 int32_t x, int32_t y,
244 int32_t width, int32_t height)
245{
246 struct wlsc_compositor *compositor = surface->compositor;
247
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400248 pixman_region32_union_rect(&surface->damage,
249 &surface->damage,
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500250 surface->x + x, surface->y + y,
251 width, height);
252 wlsc_compositor_schedule_repaint(compositor);
253}
254
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400255WL_EXPORT void
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500256wlsc_surface_damage(struct wlsc_surface *surface)
257{
258 wlsc_surface_damage_rectangle(surface, 0, 0,
259 surface->width, surface->height);
260}
261
Kristian Høgsbergb8a98332011-06-23 21:00:04 -0400262WL_EXPORT void
263wlsc_surface_damage_below(struct wlsc_surface *surface)
264{
265 struct wlsc_surface *below;
266
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -0500267 if (surface->output == NULL)
Pekka Paalanend503a0b2011-11-15 13:34:53 +0200268 return;
269
Kristian Høgsbergb8a98332011-06-23 21:00:04 -0400270 if (surface->link.next == &surface->compositor->surface_list)
271 return;
272
273 below = container_of(surface->link.next, struct wlsc_surface, link);
274
275 pixman_region32_union_rect(&below->damage,
276 &below->damage,
277 surface->x, surface->y,
278 surface->width, surface->height);
279 wlsc_compositor_schedule_repaint(surface->compositor);
280}
281
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400282WL_EXPORT void
283wlsc_surface_configure(struct wlsc_surface *surface,
284 int x, int y, int width, int height)
285{
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400286 wlsc_surface_damage_below(surface);
287
288 surface->x = x;
289 surface->y = y;
290 surface->width = width;
291 surface->height = height;
292
293 wlsc_surface_assign_output(surface);
294 wlsc_surface_damage(surface);
295
296 pixman_region32_fini(&surface->opaque);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400297 if (surface->visual == WLSC_RGB_VISUAL)
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400298 pixman_region32_init_rect(&surface->opaque,
299 surface->x, surface->y,
300 surface->width, surface->height);
301 else
302 pixman_region32_init(&surface->opaque);
303}
304
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400305WL_EXPORT uint32_t
306wlsc_compositor_get_time(void)
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500307{
308 struct timeval tv;
309
310 gettimeofday(&tv, NULL);
311
312 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
313}
314
Pekka Paalanenf0fc70d2011-11-15 13:34:54 +0200315WL_EXPORT void
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400316wlsc_compositor_repick(struct wlsc_compositor *compositor)
317{
318 struct wlsc_input_device *device;
319 struct wlsc_surface *surface;
320 int32_t sx, sy;
321 uint32_t time;
322
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -0500323 if (!compositor->focus)
324 return;
325
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400326 time = wlsc_compositor_get_time();
327 wl_list_for_each(device, &compositor->input_device_list, link) {
Kristian Høgsberg32ff1f52011-10-12 00:36:54 -0400328 if (device->input_device.grab)
329 continue;
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400330 surface = pick_surface(&device->input_device, &sx, &sy);
331 wl_input_device_set_pointer_focus(&device->input_device,
332 &surface->surface,
333 time,
334 device->input_device.x,
335 device->input_device.y,
336 sx, sy);
337 }
338}
339
340static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400341destroy_surface(struct wl_resource *resource)
Kristian Høgsberg54879822008-11-23 17:07:32 -0500342{
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -0400343 struct wlsc_surface *surface =
Kristian Høgsbergb313b022010-12-01 17:07:41 -0500344 container_of(resource, struct wlsc_surface, surface.resource);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400345 struct wlsc_compositor *compositor = surface->compositor;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400346
Kristian Høgsbergb8a98332011-06-23 21:00:04 -0400347 wlsc_surface_damage_below(surface);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500348
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400349 wl_list_remove(&surface->link);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400350 wlsc_compositor_repick(compositor);
351
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200352 if (surface->saved_texture == 0)
353 glDeleteTextures(1, &surface->texture);
354 else
355 glDeleteTextures(1, &surface->saved_texture);
356
Benjamin Franzke06286262011-05-06 19:12:33 +0200357 if (surface->buffer)
358 wl_list_remove(&surface->buffer_destroy_listener.link);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400359
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200360 if (surface->image != EGL_NO_IMAGE_KHR)
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400361 compositor->destroy_image(compositor->display,
362 surface->image);
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200363
Benjamin Franzkebab41fb2011-03-07 18:04:59 +0100364 wl_list_remove(&surface->buffer_link);
365
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400366 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500367}
368
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100369static void
370wlsc_buffer_attach(struct wl_buffer *buffer, struct wl_surface *surface)
371{
372 struct wlsc_surface *es = (struct wlsc_surface *) surface;
373 struct wlsc_compositor *ec = es->compositor;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100374 struct wl_list *surfaces_attached_to;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100375
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100376 if (es->saved_texture != 0)
377 es->texture = es->saved_texture;
378
379 glBindTexture(GL_TEXTURE_2D, es->texture);
380
381 if (wl_buffer_is_shm(buffer)) {
382 /* Unbind any EGLImage texture that may be bound, so we don't
383 * overwrite it.*/
384 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
385 0, 0, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200386 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100387 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200388 es->pitch, buffer->height, 0,
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100389 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
390 wl_shm_buffer_get_data(buffer));
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400391
392 switch (wl_shm_buffer_get_format(buffer)) {
393 case WL_SHM_FORMAT_ARGB32:
394 es->visual = WLSC_ARGB_VISUAL;
395 break;
396 case WL_SHM_FORMAT_PREMULTIPLIED_ARGB32:
397 es->visual = WLSC_PREMUL_ARGB_VISUAL;
398 break;
399 case WL_SHM_FORMAT_XRGB32:
400 es->visual = WLSC_RGB_VISUAL;
401 break;
402 }
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100403
404 surfaces_attached_to = buffer->user_data;
405
Kristian Høgsbergfac11d22011-05-02 13:35:17 -0400406 wl_list_remove(&es->buffer_link);
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100407 wl_list_insert(surfaces_attached_to, &es->buffer_link);
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100408 } else {
Benjamin Franzkefb4b5a22011-06-21 10:44:37 +0200409 if (es->image != EGL_NO_IMAGE_KHR)
410 ec->destroy_image(ec->display, es->image);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400411 es->image = ec->create_image(ec->display, NULL,
412 EGL_WAYLAND_BUFFER_WL,
413 buffer, NULL);
414
415 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400416
417 /* FIXME: we need to get the visual from the wl_buffer */
418 es->visual = WLSC_PREMUL_ARGB_VISUAL;
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200419 es->pitch = es->width;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100420 }
421}
422
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200423static void
424wlsc_sprite_attach(struct wlsc_sprite *sprite, struct wl_surface *surface)
425{
426 struct wlsc_surface *es = (struct wlsc_surface *) surface;
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400427 struct wlsc_compositor *ec = es->compositor;
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200428
Ander Conselvan de Oliveira0de0aaf2011-10-27 17:09:17 +0300429 es->pitch = sprite->width;
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200430 es->image = sprite->image;
431 if (sprite->image != EGL_NO_IMAGE_KHR) {
432 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400433 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200434 } else {
435 if (es->saved_texture == 0)
436 es->saved_texture = es->texture;
437 es->texture = sprite->texture;
438 }
439
440 es->visual = sprite->visual;
Benjamin Franzke06286262011-05-06 19:12:33 +0200441
442 if (es->buffer)
443 es->buffer = NULL;
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200444}
445
446enum sprite_usage {
447 SPRITE_USE_CURSOR = (1 << 0),
448};
449
450static struct wlsc_sprite *
451create_sprite_from_png(struct wlsc_compositor *ec,
Kristian Høgsbergb41d76c2011-04-23 15:03:15 -0400452 const char *filename, uint32_t usage)
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500453{
Kristian Høgsbergff298d92011-10-28 20:41:28 -0400454 uint32_t *pixels, *pad;
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200455 struct wlsc_sprite *sprite;
Kristian Høgsbergb41d76c2011-04-23 15:03:15 -0400456 int32_t width, height;
457 uint32_t stride;
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500458
Kristian Høgsbergb41d76c2011-04-23 15:03:15 -0400459 pixels = wlsc_load_image(filename, &width, &height, &stride);
460 if (pixels == NULL)
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200461 return NULL;
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500462
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200463 sprite = malloc(sizeof *sprite);
464 if (sprite == NULL) {
465 free(pixels);
466 return NULL;
467 }
468
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400469 sprite->visual = WLSC_PREMUL_ARGB_VISUAL;
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200470 sprite->width = width;
471 sprite->height = height;
472 sprite->image = EGL_NO_IMAGE_KHR;
473
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200474 glGenTextures(1, &sprite->texture);
475 glBindTexture(GL_TEXTURE_2D, sprite->texture);
476 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
477 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
478 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
479 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
480
Kristian Høgsbergff298d92011-10-28 20:41:28 -0400481 if (usage & SPRITE_USE_CURSOR && ec->create_cursor_image != NULL) {
482 sprite->image = ec->create_cursor_image(ec, &sprite->width,
483 &sprite->height);
484
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400485 ec->image_target_texture_2d(GL_TEXTURE_2D, sprite->image);
Kristian Høgsbergff298d92011-10-28 20:41:28 -0400486
487 if (sprite->width > width || sprite->height > height) {
488 pad = calloc(sprite->width * sprite->height,
489 sizeof *pad);
490 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
491 sprite->width, sprite->height,
492 GL_BGRA_EXT, GL_UNSIGNED_BYTE, pad);
493 free(pad);
494 }
495
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200496 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height,
497 GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
Ander Conselvan de Oliveira0de0aaf2011-10-27 17:09:17 +0300498
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200499 } else {
500 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, width, height, 0,
501 GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
502 }
Kristian Høgsberg8525a502011-01-14 16:20:21 -0500503
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500504 free(pixels);
Kristian Høgsberg8525a502011-01-14 16:20:21 -0500505
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200506 return sprite;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500507}
508
Kristian Høgsberg1db21f12010-08-16 16:08:12 -0400509static const struct {
510 const char *filename;
511 int hotspot_x, hotspot_y;
512} pointer_images[] = {
Kristian Høgsberg4219a402010-08-16 16:43:03 -0400513 { DATADIR "/wayland/bottom_left_corner.png", 6, 30 },
514 { DATADIR "/wayland/bottom_right_corner.png", 28, 28 },
515 { DATADIR "/wayland/bottom_side.png", 16, 20 },
516 { DATADIR "/wayland/grabbing.png", 20, 17 },
517 { DATADIR "/wayland/left_ptr.png", 10, 5 },
518 { DATADIR "/wayland/left_side.png", 10, 20 },
519 { DATADIR "/wayland/right_side.png", 30, 19 },
520 { DATADIR "/wayland/top_left_corner.png", 8, 8 },
521 { DATADIR "/wayland/top_right_corner.png", 26, 8 },
522 { DATADIR "/wayland/top_side.png", 18, 8 },
523 { DATADIR "/wayland/xterm.png", 15, 15 }
Kristian Høgsberg1db21f12010-08-16 16:08:12 -0400524};
525
526static void
527create_pointer_images(struct wlsc_compositor *ec)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500528{
Kristian Høgsberg1db21f12010-08-16 16:08:12 -0400529 int i, count;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400530
Kristian Høgsberg1db21f12010-08-16 16:08:12 -0400531 count = ARRAY_LENGTH(pointer_images);
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200532 ec->pointer_sprites = malloc(count * sizeof *ec->pointer_sprites);
Kristian Høgsberg1db21f12010-08-16 16:08:12 -0400533 for (i = 0; i < count; i++) {
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200534 ec->pointer_sprites[i] =
535 create_sprite_from_png(ec,
Kristian Høgsberg8525a502011-01-14 16:20:21 -0500536 pointer_images[i].filename,
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200537 SPRITE_USE_CURSOR);
Rob Bradford1d724472011-10-25 13:43:44 +0100538 if (!ec->pointer_sprites[i]) {
539 fprintf(stderr, "Error loading pointer image: %s\n",
540 pointer_images[i].filename);
541 }
Kristian Høgsberg1db21f12010-08-16 16:08:12 -0400542 }
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400543}
544
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400545static int
546texture_region(struct wlsc_surface *es, pixman_region32_t *region)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500547{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500548 struct wlsc_compositor *ec = es->compositor;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500549 GLfloat *v, inv_width, inv_height;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500550 pixman_box32_t *rectangles;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400551 unsigned int *p;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500552 int i, n;
553
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400554 rectangles = pixman_region32_rectangles(region, &n);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500555 v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
556 p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200557 inv_width = 1.0 / es->pitch;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500558 inv_height = 1.0 / es->height;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400559
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500560 for (i = 0; i < n; i++, v += 16, p += 6) {
561 v[ 0] = rectangles[i].x1;
562 v[ 1] = rectangles[i].y1;
563 v[ 2] = (GLfloat) (rectangles[i].x1 - es->x) * inv_width;
564 v[ 3] = (GLfloat) (rectangles[i].y1 - es->y) * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500565
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500566 v[ 4] = rectangles[i].x1;
567 v[ 5] = rectangles[i].y2;
568 v[ 6] = v[ 2];
569 v[ 7] = (GLfloat) (rectangles[i].y2 - es->y) * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500570
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500571 v[ 8] = rectangles[i].x2;
572 v[ 9] = rectangles[i].y1;
573 v[10] = (GLfloat) (rectangles[i].x2 - es->x) * inv_width;
574 v[11] = v[ 3];
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500575
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500576 v[12] = rectangles[i].x2;
577 v[13] = rectangles[i].y2;
578 v[14] = v[10];
579 v[15] = v[ 7];
580
581 p[0] = i * 4 + 0;
582 p[1] = i * 4 + 1;
583 p[2] = i * 4 + 2;
584 p[3] = i * 4 + 2;
585 p[4] = i * 4 + 1;
586 p[5] = i * 4 + 3;
587 }
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500588
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400589 return n;
590}
591
592static void
593transform_vertex(struct wlsc_surface *surface,
594 GLfloat x, GLfloat y, GLfloat u, GLfloat v, GLfloat *r)
595{
596 struct wlsc_vector t;
597
598 t.f[0] = x;
599 t.f[1] = y;
600 t.f[2] = 0.0;
601 t.f[3] = 1.0;
602
Kristian Høgsberg0bc0e242011-05-02 14:35:40 -0400603 wlsc_matrix_transform(&surface->transform->matrix, &t);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400604
605 r[ 0] = t.f[0];
606 r[ 1] = t.f[1];
607 r[ 2] = u;
608 r[ 3] = v;
609}
610
611static int
612texture_transformed_surface(struct wlsc_surface *es)
613{
614 struct wlsc_compositor *ec = es->compositor;
615 GLfloat *v;
616 unsigned int *p;
617
618 v = wl_array_add(&ec->vertices, 16 * sizeof *v);
619 p = wl_array_add(&ec->indices, 6 * sizeof *p);
620
621 transform_vertex(es, es->x, es->y, 0.0, 0.0, &v[0]);
622 transform_vertex(es, es->x, es->y + es->height, 0.0, 1.0, &v[4]);
623 transform_vertex(es, es->x + es->width, es->y, 1.0, 0.0, &v[8]);
624 transform_vertex(es, es->x + es->width, es->y + es->height,
625 1.0, 1.0, &v[12]);
626
627 p[0] = 0;
628 p[1] = 1;
629 p[2] = 2;
630 p[3] = 2;
631 p[4] = 1;
632 p[5] = 3;
633
634 return 1;
635}
636
637static void
638wlsc_surface_draw(struct wlsc_surface *es,
639 struct wlsc_output *output, pixman_region32_t *clip)
640{
641 struct wlsc_compositor *ec = es->compositor;
642 GLfloat *v;
643 pixman_region32_t repaint;
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400644 GLint filter;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400645 int n;
646
647 pixman_region32_init_rect(&repaint,
648 es->x, es->y, es->width, es->height);
649 pixman_region32_intersect(&repaint, &repaint, clip);
650 if (!pixman_region32_not_empty(&repaint))
651 return;
652
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400653 switch (es->visual) {
654 case WLSC_ARGB_VISUAL:
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400655 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
656 glEnable(GL_BLEND);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400657 break;
658 case WLSC_PREMUL_ARGB_VISUAL:
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400659 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
660 glEnable(GL_BLEND);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400661 break;
662 case WLSC_RGB_VISUAL:
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400663 glDisable(GL_BLEND);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400664 break;
665 default:
666 fprintf(stderr, "bogus visual\n");
667 break;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400668 }
669
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400670 if (es->transform == NULL) {
671 filter = GL_NEAREST;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400672 n = texture_region(es, &repaint);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400673 } else {
674 filter = GL_LINEAR;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400675 n = texture_transformed_surface(es);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400676 }
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400677
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500678 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400679 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
680 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
681
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500682 v = ec->vertices.data;
683 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
684 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400685 glEnableVertexAttribArray(0);
686 glEnableVertexAttribArray(1);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500687 glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
688
689 ec->vertices.size = 0;
690 ec->indices.size = 0;
691 pixman_region32_fini(&repaint);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500692}
693
694static void
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400695wlsc_surface_raise(struct wlsc_surface *surface)
696{
697 struct wlsc_compositor *compositor = surface->compositor;
698
699 wl_list_remove(&surface->link);
Kristian Høgsberg747638b2010-07-12 17:06:06 -0400700 wl_list_insert(&compositor->surface_list, &surface->link);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400701 wlsc_compositor_repick(compositor);
Kristian Høgsbergcd0d10b2011-06-24 08:28:07 -0400702 wlsc_surface_damage(surface);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400703}
704
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400705WL_EXPORT void
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400706wlsc_compositor_damage_all(struct wlsc_compositor *compositor)
707{
708 struct wlsc_output *output;
709
710 wl_list_for_each(output, &compositor->output_list, link)
711 wlsc_output_damage(output);
712}
713
Benjamin Franzke06286262011-05-06 19:12:33 +0200714static inline void
715wlsc_buffer_post_release(struct wl_buffer *buffer)
716{
Kristian Høgsberg24596942011-10-24 17:51:02 -0400717 if (--buffer->busy_count > 0)
Benjamin Franzke06286262011-05-06 19:12:33 +0200718 return;
Benjamin Franzke06286262011-05-06 19:12:33 +0200719
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400720 assert(buffer->resource.client != NULL);
Kristian Høgsbergeccef6a2011-11-17 16:46:19 -0500721 wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
Benjamin Franzke06286262011-05-06 19:12:33 +0200722}
723
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400724WL_EXPORT void
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400725wlsc_output_damage(struct wlsc_output *output)
726{
727 struct wlsc_compositor *compositor = output->compositor;
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500728 struct wlsc_surface *es;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400729
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500730 if (wl_list_empty(&compositor->surface_list))
731 return;
732
733 es = container_of(compositor->surface_list.next,
734 struct wlsc_surface, link);
735 pixman_region32_union(&es->damage, &es->damage, &output->region);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400736 wlsc_compositor_schedule_repaint(compositor);
737}
738
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400739static void
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400740fade_frame(struct wlsc_animation *animation,
741 struct wlsc_output *output, uint32_t msecs)
742{
743 struct wlsc_compositor *compositor =
744 container_of(animation,
745 struct wlsc_compositor, fade.animation);
746
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400747 wlsc_spring_update(&compositor->fade.spring, msecs);
748 if (wlsc_spring_done(&compositor->fade.spring)) {
749 if (compositor->fade.spring.current > 0.999) {
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400750 compositor->state = WLSC_COMPOSITOR_SLEEPING;
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400751 compositor->shell->lock(compositor->shell);
752 }
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400753 compositor->fade.spring.current =
754 compositor->fade.spring.target;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400755 wl_list_remove(&animation->link);
756 wl_list_init(&animation->link);
757 }
758
759 wlsc_output_damage(output);
760}
761
762static void
763fade_output(struct wlsc_output *output,
764 GLfloat tint, pixman_region32_t *region)
765{
766 struct wlsc_compositor *compositor = output->compositor;
767 struct wlsc_surface surface;
768 GLfloat color[4] = { 0.0, 0.0, 0.0, tint };
769
770 surface.compositor = compositor;
771 surface.x = output->x;
772 surface.y = output->y;
Tiago Vignatti2cc8b872011-08-19 15:10:40 +0300773 surface.pitch = output->current->width;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400774 surface.width = output->current->width;
775 surface.height = output->current->height;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400776 surface.texture = GL_NONE;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400777 surface.transform = NULL;
Kristian Høgsbergc352ab02011-04-23 15:34:50 -0400778
779 if (tint <= 1.0)
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400780 surface.visual = WLSC_PREMUL_ARGB_VISUAL;
Kristian Høgsbergc352ab02011-04-23 15:34:50 -0400781 else
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400782 surface.visual = WLSC_RGB_VISUAL;
Kristian Høgsbergc352ab02011-04-23 15:34:50 -0400783
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400784 glUseProgram(compositor->solid_shader.program);
785 glUniformMatrix4fv(compositor->solid_shader.proj_uniform,
786 1, GL_FALSE, output->matrix.d);
787 glUniform4fv(compositor->solid_shader.color_uniform, 1, color);
788 wlsc_surface_draw(&surface, output, region);
789}
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200790
791static void
792wlsc_output_set_cursor(struct wlsc_output *output,
793 struct wl_input_device *dev, int force_sw)
794{
795 struct wlsc_compositor *ec = output->compositor;
796 struct wlsc_input_device *device = (struct wlsc_input_device *) dev;
797 pixman_region32_t cursor_region;
798 int use_hardware_cursor = 1, prior_was_hardware;
799
800 pixman_region32_init_rect(&cursor_region,
801 device->sprite->x, device->sprite->y,
802 device->sprite->width,
803 device->sprite->height);
804
805 pixman_region32_intersect(&cursor_region, &cursor_region, &output->region);
806
807 if (!pixman_region32_not_empty(&cursor_region)) {
Ander Conselvan de Oliveira02924bc2011-10-24 16:30:15 +0300808 output->set_hardware_cursor(output, NULL);
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200809 goto out;
810 }
811
812 prior_was_hardware = wl_list_empty(&device->sprite->link);
813 if (force_sw || output->set_hardware_cursor(output, device) < 0) {
Matt Roper11568a72011-08-29 15:59:37 -0700814 if (prior_was_hardware) {
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200815 wlsc_surface_damage(device->sprite);
Matt Roper11568a72011-08-29 15:59:37 -0700816 output->set_hardware_cursor(output, NULL);
817 }
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200818 use_hardware_cursor = 0;
819 } else if (!prior_was_hardware) {
820 wlsc_surface_damage_below(device->sprite);
821 }
822
823 /* Remove always to be on top. */
824 wl_list_remove(&device->sprite->link);
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500825 if (!use_hardware_cursor && ec->focus) {
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200826 wl_list_insert(&ec->surface_list, &device->sprite->link);
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500827 device->sprite->output = output;
828 } else {
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200829 wl_list_init(&device->sprite->link);
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500830 device->sprite->output = NULL;
831 }
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200832
833out:
834 pixman_region32_fini(&cursor_region);
835}
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400836
Ander Conselvan de Oliveira3b199662011-10-18 17:02:06 +0300837static int
838setup_scanout_surface(struct wlsc_output *output, struct wlsc_surface *es)
839{
840 if (es->visual != WLSC_RGB_VISUAL ||
841 output->prepare_scanout_surface(output, es) != 0)
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400842 return -1;
Ander Conselvan de Oliveira3b199662011-10-18 17:02:06 +0300843
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400844 /* assert output->pending_scanout_buffer == NULL */
845 output->pending_scanout_buffer = es->buffer;
846 output->pending_scanout_buffer->busy_count++;
Ander Conselvan de Oliveira3b199662011-10-18 17:02:06 +0300847
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400848 wl_list_insert(output->pending_scanout_buffer->resource.destroy_listener_list.prev,
849 &output->pending_scanout_buffer_destroy_listener.link);
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300850
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400851 return 0;
Ander Conselvan de Oliveira3b199662011-10-18 17:02:06 +0300852}
853
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400854static void
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400855wlsc_output_repaint(struct wlsc_output *output)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400856{
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500857 struct wlsc_compositor *ec = output->compositor;
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500858 struct wlsc_surface *es;
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400859 pixman_region32_t opaque, new_damage, total_damage, repaint;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500860
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100861 output->prepare_render(output);
862
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400863 glViewport(0, 0, output->current->width, output->current->height);
Kristian Høgsbergfdec2362001-01-01 22:23:51 -0500864
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -0400865 glUseProgram(ec->texture_shader.program);
866 glUniformMatrix4fv(ec->texture_shader.proj_uniform,
867 1, GL_FALSE, output->matrix.d);
868 glUniform1i(ec->texture_shader.tex_uniform, 0);
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500869
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200870 wlsc_output_set_cursor(output, ec->input_device,
Kristian Høgsberg4ebf3a02011-08-29 16:47:09 -0400871 ec->fade.spring.current >= 0.001);
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200872
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500873 pixman_region32_init(&new_damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400874 pixman_region32_init(&opaque);
875
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400876 wl_list_for_each(es, &ec->surface_list, link) {
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400877 pixman_region32_subtract(&es->damage, &es->damage, &opaque);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400878 pixman_region32_union(&new_damage, &new_damage, &es->damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400879 pixman_region32_union(&opaque, &opaque, &es->opaque);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400880 }
881
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400882 pixman_region32_init(&total_damage);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500883 pixman_region32_union(&total_damage, &new_damage,
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400884 &output->previous_damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400885 pixman_region32_intersect(&output->previous_damage,
886 &new_damage, &output->region);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500887
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400888 pixman_region32_fini(&opaque);
Kristian Høgsberg53df1d82011-06-23 21:11:19 -0400889 pixman_region32_fini(&new_damage);
890
Kristian Høgsberg0ce24572011-01-28 15:18:33 -0500891 es = container_of(ec->surface_list.next, struct wlsc_surface, link);
Benjamin Franzke66aa2352011-04-20 17:06:13 +0200892
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500893 if (setup_scanout_surface(output, es) == 0)
894 /* We're drawing nothing, just let the damage accumulate */
Kristian Høgsberg8244b442011-06-23 15:44:14 -0400895 return;
Kristian Høgsberg4d07a1c2011-05-06 14:03:12 -0400896
897 if (es->fullscreen_output == output) {
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400898 if (es->width < output->current->width ||
899 es->height < output->current->height)
Benjamin Franzke66aa2352011-04-20 17:06:13 +0200900 glClear(GL_COLOR_BUFFER_BIT);
901 wlsc_surface_draw(es, output, &total_damage);
Kristian Høgsberg0ce24572011-01-28 15:18:33 -0500902 } else {
Kristian Høgsbergaee7f842011-06-23 21:25:20 -0400903 wl_list_for_each(es, &ec->surface_list, link) {
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400904 pixman_region32_copy(&es->damage, &total_damage);
905 pixman_region32_subtract(&total_damage, &total_damage, &es->opaque);
Kristian Høgsbergaee7f842011-06-23 21:25:20 -0400906 }
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -0500907
Kristian Høgsbergaee7f842011-06-23 21:25:20 -0400908 wl_list_for_each_reverse(es, &ec->surface_list, link) {
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400909 pixman_region32_init(&repaint);
910 pixman_region32_intersect(&repaint, &output->region,
911 &es->damage);
912 wlsc_surface_draw(es, output, &repaint);
913 pixman_region32_subtract(&es->damage,
914 &es->damage, &output->region);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -0500915 }
Kristian Høgsberg0ce24572011-01-28 15:18:33 -0500916 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400917
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400918 if (ec->fade.spring.current > 0.001)
919 fade_output(output, ec->fade.spring.current, &total_damage);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500920}
921
Kristian Høgsberg33418202011-08-16 23:01:28 -0400922struct wlsc_frame_callback {
923 struct wl_resource resource;
Kristian Høgsberg33418202011-08-16 23:01:28 -0400924 struct wl_list link;
925};
926
Kristian Høgsbergef044142011-06-21 15:02:12 -0400927static void
928repaint(void *data, int msecs)
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500929{
Kristian Høgsbergef044142011-06-21 15:02:12 -0400930 struct wlsc_output *output = data;
931 struct wlsc_compositor *compositor = output->compositor;
Kristian Høgsbergef044142011-06-21 15:02:12 -0400932 struct wlsc_animation *animation, *next;
Kristian Høgsberg33418202011-08-16 23:01:28 -0400933 struct wlsc_frame_callback *cb, *cnext;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500934
Kristian Høgsbergef044142011-06-21 15:02:12 -0400935 wlsc_output_repaint(output);
936 output->repaint_needed = 0;
937 output->repaint_scheduled = 1;
938 output->present(output);
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100939
Kristian Høgsberg33418202011-08-16 23:01:28 -0400940 wl_list_for_each_safe(cb, cnext, &output->frame_callback_list, link) {
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400941 wl_resource_post_event(&cb->resource, WL_CALLBACK_DONE, msecs);
942 wl_resource_destroy(&cb->resource, 0);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500943 }
944
Kristian Høgsbergef044142011-06-21 15:02:12 -0400945 wl_list_for_each_safe(animation, next,
946 &compositor->animation_list, link)
947 animation->frame(animation, output, msecs);
948}
Kristian Høgsbergb1868472011-04-22 12:27:57 -0400949
Kristian Høgsbergef044142011-06-21 15:02:12 -0400950static void
951idle_repaint(void *data)
952{
953 repaint(data, wlsc_compositor_get_time());
954}
955
956WL_EXPORT void
957wlsc_output_finish_frame(struct wlsc_output *output, int msecs)
958{
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400959 if (output->scanout_buffer) {
960 wlsc_buffer_post_release(output->scanout_buffer);
961 wl_list_remove(&output->scanout_buffer_destroy_listener.link);
962 output->scanout_buffer = NULL;
963 }
964
965 if (output->pending_scanout_buffer) {
966 output->scanout_buffer = output->pending_scanout_buffer;
967 wl_list_remove(&output->pending_scanout_buffer_destroy_listener.link);
968 wl_list_insert(output->scanout_buffer->resource.destroy_listener_list.prev,
969 &output->scanout_buffer_destroy_listener.link);
970 output->pending_scanout_buffer = NULL;
971 }
972
Kristian Høgsbergef044142011-06-21 15:02:12 -0400973 if (output->repaint_needed)
974 repaint(output, msecs);
Ander Conselvan de Oliveira22e22a52011-10-24 16:30:14 +0300975 else
976 output->repaint_scheduled = 0;
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400977}
978
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400979WL_EXPORT void
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400980wlsc_compositor_schedule_repaint(struct wlsc_compositor *compositor)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400981{
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100982 struct wlsc_output *output;
Kristian Høgsbergef044142011-06-21 15:02:12 -0400983 struct wl_event_loop *loop;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100984
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400985 if (compositor->state == WLSC_COMPOSITOR_SLEEPING)
986 return;
987
Kristian Høgsbergef044142011-06-21 15:02:12 -0400988 loop = wl_display_get_event_loop(compositor->wl_display);
989 wl_list_for_each(output, &compositor->output_list, link) {
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100990 output->repaint_needed = 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -0400991 if (output->repaint_scheduled)
992 continue;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100993
Kristian Høgsbergef044142011-06-21 15:02:12 -0400994 wl_event_loop_add_idle(loop, idle_repaint, output);
995 output->repaint_scheduled = 1;
996 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400997}
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500998
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400999WL_EXPORT void
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001000wlsc_compositor_fade(struct wlsc_compositor *compositor, float tint)
1001{
1002 int done;
1003
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001004 done = wlsc_spring_done(&compositor->fade.spring);
1005 compositor->fade.spring.target = tint;
1006 if (wlsc_spring_done(&compositor->fade.spring))
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001007 return;
1008
1009 if (done)
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001010 compositor->fade.spring.timestamp =
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001011 wlsc_compositor_get_time();
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001012
1013 wlsc_compositor_damage_all(compositor);
1014 if (wl_list_empty(&compositor->fade.animation.link))
1015 wl_list_insert(compositor->animation_list.prev,
1016 &compositor->fade.animation.link);
1017}
1018
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001019static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001020surface_destroy(struct wl_client *client, struct wl_resource *resource)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001021{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001022 wl_resource_destroy(resource, wlsc_compositor_get_time());
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001023}
1024
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001025WL_EXPORT void
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001026wlsc_surface_assign_output(struct wlsc_surface *es)
1027{
1028 struct wlsc_compositor *ec = es->compositor;
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001029 struct wlsc_output *output, *new_output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001030 pixman_region32_t region;
1031 uint32_t max, area;
1032 pixman_box32_t *e;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001033
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001034 new_output = NULL;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001035 max = 0;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001036 wl_list_for_each(output, &ec->output_list, link) {
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001037 pixman_region32_init_rect(&region,
1038 es->x, es->y, es->width, es->height);
1039 pixman_region32_intersect(&region, &region, &output->region);
1040
1041 e = pixman_region32_extents(&region);
1042 area = (e->x2 - e->x1) * (e->y2 - e->y1);
1043
1044 if (area >= max) {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001045 new_output = output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001046 max = area;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001047 }
1048 }
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001049
1050 es->output = new_output;
1051 if (!wl_list_empty(&es->frame_callback_list)) {
1052 wl_list_insert_list(new_output->frame_callback_list.prev,
1053 &es->frame_callback_list);
1054 wl_list_init(&es->frame_callback_list);
1055 }
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001056}
1057
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001058static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001059surface_attach(struct wl_client *client,
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001060 struct wl_resource *resource,
1061 struct wl_resource *buffer_resource, int32_t x, int32_t y)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001062{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001063 struct wlsc_surface *es = resource->data;
Kristian Høgsberg32e24cc2011-11-09 12:07:35 -05001064 struct wlsc_shell *shell = es->compositor->shell;
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001065 struct wl_buffer *buffer = buffer_resource->data;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001066
Kristian Høgsberg24596942011-10-24 17:51:02 -04001067 if (es->buffer) {
1068 wlsc_buffer_post_release(es->buffer);
1069 wl_list_remove(&es->buffer_destroy_listener.link);
1070 }
Benjamin Franzke06286262011-05-06 19:12:33 +02001071
Kristian Høgsberg24596942011-10-24 17:51:02 -04001072 buffer->busy_count++;
Benjamin Franzke06286262011-05-06 19:12:33 +02001073 es->buffer = buffer;
Benjamin Franzke06286262011-05-06 19:12:33 +02001074 wl_list_insert(es->buffer->resource.destroy_listener_list.prev,
1075 &es->buffer_destroy_listener.link);
1076
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001077 if (es->visual == WLSC_NONE_VISUAL) {
Kristian Høgsberg32e24cc2011-11-09 12:07:35 -05001078 shell->map(shell, es, buffer->width, buffer->height);
1079 } else if (x != 0 || y != 0 ||
1080 es->width != buffer->width ||
1081 es->height != buffer->height) {
1082 shell->configure(shell, es, es->x + x, es->y + y,
1083 buffer->width, buffer->height);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001084 }
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001085
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001086 wlsc_buffer_attach(buffer, &es->surface);
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001087}
1088
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001089static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001090surface_damage(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001091 struct wl_resource *resource,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001092 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -05001093{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001094 struct wlsc_surface *es = resource->data;
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -04001095
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001096 wlsc_surface_damage_rectangle(es, x, y, width, height);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001097}
1098
Kristian Høgsberg33418202011-08-16 23:01:28 -04001099static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001100destroy_frame_callback(struct wl_resource *resource)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001101{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001102 struct wlsc_frame_callback *cb = resource->data;
1103
1104 wl_list_remove(&cb->link);
Pekka Paalanen8c196452011-11-15 11:45:42 +02001105 free(cb);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001106}
1107
1108static void
1109surface_frame(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001110 struct wl_resource *resource, uint32_t callback)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001111{
1112 struct wlsc_frame_callback *cb;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001113 struct wlsc_surface *es = resource->data;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001114
1115 cb = malloc(sizeof *cb);
1116 if (cb == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001117 wl_resource_post_no_memory(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001118 return;
1119 }
1120
1121 cb->resource.object.interface = &wl_callback_interface;
1122 cb->resource.object.id = callback;
1123 cb->resource.destroy = destroy_frame_callback;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001124 cb->resource.client = client;
1125 cb->resource.data = cb;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001126
1127 wl_client_add_resource(client, &cb->resource);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001128
1129 if (es->output) {
1130 wl_list_insert(es->output->frame_callback_list.prev,
1131 &cb->link);
1132 } else {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001133 wl_list_insert(es->frame_callback_list.prev, &cb->link);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001134 }
Kristian Høgsberg33418202011-08-16 23:01:28 -04001135}
1136
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001137const static struct wl_surface_interface surface_interface = {
1138 surface_destroy,
1139 surface_attach,
Kristian Høgsberg33418202011-08-16 23:01:28 -04001140 surface_damage,
1141 surface_frame
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001142};
1143
1144static void
Kristian Høgsbergeef08fb2010-08-17 21:23:10 -04001145wlsc_input_device_attach(struct wlsc_input_device *device,
Benjamin Franzke431da9a2011-04-20 11:02:58 +02001146 int x, int y, int width, int height)
Kristian Høgsberg1db21f12010-08-16 16:08:12 -04001147{
Kristian Høgsbergb8a98332011-06-23 21:00:04 -04001148 wlsc_surface_damage_below(device->sprite);
Kristian Høgsberg1db21f12010-08-16 16:08:12 -04001149
Kristian Høgsbergeef08fb2010-08-17 21:23:10 -04001150 device->hotspot_x = x;
1151 device->hotspot_y = y;
Kristian Høgsberg1db21f12010-08-16 16:08:12 -04001152
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001153 device->sprite->x = device->input_device.x - device->hotspot_x;
1154 device->sprite->y = device->input_device.y - device->hotspot_y;
Benjamin Franzke431da9a2011-04-20 11:02:58 +02001155 device->sprite->width = width;
1156 device->sprite->height = height;
Kristian Høgsberg1db21f12010-08-16 16:08:12 -04001157
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001158 wlsc_surface_damage(device->sprite);
Kristian Høgsberg1db21f12010-08-16 16:08:12 -04001159}
1160
Benjamin Franzke431da9a2011-04-20 11:02:58 +02001161static void
1162wlsc_input_device_attach_buffer(struct wlsc_input_device *device,
1163 struct wl_buffer *buffer, int x, int y)
1164{
1165 wlsc_buffer_attach(buffer, &device->sprite->surface);
1166 wlsc_input_device_attach(device, x, y, buffer->width, buffer->height);
1167}
1168
1169static void
1170wlsc_input_device_attach_sprite(struct wlsc_input_device *device,
1171 struct wlsc_sprite *sprite, int x, int y)
1172{
Rob Bradfordd3547112011-10-25 13:38:31 +01001173 if (!sprite)
1174 return;
1175
Benjamin Franzke431da9a2011-04-20 11:02:58 +02001176 wlsc_sprite_attach(sprite, &device->sprite->surface);
1177 wlsc_input_device_attach(device, x, y, sprite->width, sprite->height);
1178}
Kristian Høgsbergeef08fb2010-08-17 21:23:10 -04001179
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001180WL_EXPORT void
Kristian Høgsbergeef08fb2010-08-17 21:23:10 -04001181wlsc_input_device_set_pointer_image(struct wlsc_input_device *device,
1182 enum wlsc_pointer_type type)
1183{
Kristian Høgsberga8873122011-11-23 10:39:34 -05001184 struct wlsc_compositor *compositor = device->compositor;
Kristian Høgsbergeef08fb2010-08-17 21:23:10 -04001185
Benjamin Franzke431da9a2011-04-20 11:02:58 +02001186 wlsc_input_device_attach_sprite(device,
1187 compositor->pointer_sprites[type],
1188 pointer_images[type].hotspot_x,
1189 pointer_images[type].hotspot_y);
Kristian Høgsbergeef08fb2010-08-17 21:23:10 -04001190}
1191
Kristian Høgsberg83fc0612010-08-04 22:44:55 -04001192static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001193compositor_create_surface(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001194 struct wl_resource *resource, uint32_t id)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001195{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001196 struct wlsc_compositor *ec = resource->data;
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -04001197 struct wlsc_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001198
Kristian Høgsbergc5d6be92011-01-14 16:22:37 -05001199 surface = wlsc_surface_create(ec, 0, 0, 0, 0);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001200 if (surface == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001201 wl_resource_post_no_memory(resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001202 return;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001203 }
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001204
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001205 surface->surface.resource.destroy = destroy_surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001206
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001207 surface->surface.resource.object.id = id;
1208 surface->surface.resource.object.interface = &wl_surface_interface;
1209 surface->surface.resource.object.implementation =
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001210 (void (**)(void)) &surface_interface;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001211 surface->surface.resource.data = surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001212
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001213 wl_client_add_resource(client, &surface->surface.resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001214}
1215
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001216const static struct wl_compositor_interface compositor_interface = {
1217 compositor_create_surface,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001218};
1219
Kristian Høgsberg7b6907f2009-02-14 17:47:55 -05001220static void
1221wlsc_surface_transform(struct wlsc_surface *surface,
1222 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
1223{
Kristian Høgsberg2e94d112011-05-02 13:47:51 -04001224 *sx = x - surface->x;
1225 *sy = y - surface->y;
Kristian Høgsberg7b6907f2009-02-14 17:47:55 -05001226}
1227
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001228WL_EXPORT struct wlsc_surface *
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001229pick_surface(struct wl_input_device *device, int32_t *sx, int32_t *sy)
Kristian Høgsberg201a9042008-12-10 00:40:50 -05001230{
Kristian Høgsberga8873122011-11-23 10:39:34 -05001231 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1232 struct wlsc_compositor *ec = wd->compositor;
Kristian Høgsberg8e438622009-01-26 23:07:00 -05001233 struct wlsc_surface *es;
Kristian Høgsberg201a9042008-12-10 00:40:50 -05001234
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001235 wl_list_for_each(es, &ec->surface_list, link) {
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001236 if (es->surface.resource.client == NULL)
Kristian Høgsberg8244b442011-06-23 15:44:14 -04001237 continue;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001238 wlsc_surface_transform(es, device->x, device->y, sx, sy);
1239 if (0 <= *sx && *sx < es->width &&
1240 0 <= *sy && *sy < es->height)
Kristian Høgsberg201a9042008-12-10 00:40:50 -05001241 return es;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001242 }
Kristian Høgsberg201a9042008-12-10 00:40:50 -05001243
Kristian Høgsberg201a9042008-12-10 00:40:50 -05001244 return NULL;
1245}
1246
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001247
1248static void
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001249implicit_grab_motion(struct wl_grab *grab,
1250 uint32_t time, int32_t x, int32_t y)
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001251{
1252 struct wlsc_input_device *device =
1253 (struct wlsc_input_device *) grab->input_device;
1254 struct wlsc_surface *es =
1255 (struct wlsc_surface *) device->input_device.pointer_focus;
1256 int32_t sx, sy;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001257 struct wl_resource *resource;
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001258
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001259 resource = grab->input_device->pointer_focus_resource;
1260 if (resource) {
1261 wlsc_surface_transform(es, x, y, &sx, &sy);
1262 wl_resource_post_event(resource, WL_INPUT_DEVICE_MOTION,
1263 time, x, y, sx, sy);
1264 }
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001265}
1266
1267static void
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001268implicit_grab_button(struct wl_grab *grab,
1269 uint32_t time, int32_t button, int32_t state)
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001270{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001271 struct wl_resource *resource;
1272
1273 resource = grab->input_device->pointer_focus_resource;
1274 if (resource)
1275 wl_resource_post_event(resource, WL_INPUT_DEVICE_BUTTON,
1276 time, button, state);
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001277}
1278
1279static void
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001280implicit_grab_end(struct wl_grab *grab, uint32_t time)
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001281{
1282}
1283
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001284static const struct wl_grab_interface implicit_grab_interface = {
1285 implicit_grab_motion,
1286 implicit_grab_button,
1287 implicit_grab_end
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001288};
1289
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001290WL_EXPORT void
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001291wlsc_compositor_wake(struct wlsc_compositor *compositor)
1292{
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001293 compositor->state = WLSC_COMPOSITOR_ACTIVE;
Pekka Paalanenebc598e2011-11-15 13:34:51 +02001294 wlsc_compositor_fade(compositor, 0.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001295
1296 wl_event_source_timer_update(compositor->idle_source,
1297 option_idle_time * 1000);
1298}
1299
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001300WL_EXPORT void
1301wlsc_compositor_activity(struct wlsc_compositor *compositor)
1302{
1303 if (compositor->state != WLSC_COMPOSITOR_SLEEPING) {
1304 wlsc_compositor_wake(compositor);
1305 } else {
1306 compositor->shell->unlock(compositor->shell);
1307 }
1308}
1309
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001310static void
1311wlsc_compositor_idle_inhibit(struct wlsc_compositor *compositor)
1312{
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001313 wlsc_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001314 compositor->idle_inhibit++;
1315}
1316
1317static void
1318wlsc_compositor_idle_release(struct wlsc_compositor *compositor)
1319{
1320 compositor->idle_inhibit--;
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001321 wlsc_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001322}
1323
1324static int
1325idle_handler(void *data)
1326{
1327 struct wlsc_compositor *compositor = data;
1328
1329 if (compositor->idle_inhibit)
1330 return 1;
1331
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001332 wlsc_compositor_fade(compositor, 1.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001333
1334 return 1;
1335}
1336
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001337WL_EXPORT void
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001338notify_motion(struct wl_input_device *device, uint32_t time, int x, int y)
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001339{
Kristian Høgsberg8e438622009-01-26 23:07:00 -05001340 struct wlsc_surface *es;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001341 struct wlsc_output *output;
Kristian Høgsberg6d65d5f2010-12-07 13:30:18 -05001342 const struct wl_grab_interface *interface;
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001343 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001344 struct wlsc_compositor *ec = wd->compositor;
Kristian Høgsbergfc9c28a2010-12-07 13:04:43 -05001345 int32_t sx, sy;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001346 int x_valid = 0, y_valid = 0;
1347 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 -05001348
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001349 wlsc_compositor_activity(ec);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001350
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001351 wl_list_for_each(output, &ec->output_list, link) {
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001352 if (output->x <= x && x <= output->x + output->current->width)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001353 x_valid = 1;
1354
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001355 if (output->y <= y && y <= output->y + output->current->height)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001356 y_valid = 1;
1357
1358 /* FIXME: calculate this only on output addition/deletion */
1359 if (output->x < min_x)
1360 min_x = output->x;
1361 if (output->y < min_y)
1362 min_y = output->y;
1363
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001364 if (output->x + output->current->width > max_x)
1365 max_x = output->x + output->current->width;
1366 if (output->y + output->current->height > max_y)
1367 max_y = output->y + output->current->height;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001368 }
1369
1370 if (!x_valid) {
1371 if (x < min_x)
1372 x = min_x;
1373 else if (x >= max_x)
1374 x = max_x;
1375 }
1376 if (!y_valid) {
1377 if (y < min_y)
1378 y = min_y;
1379 else if (y >= max_y)
1380 y = max_y;
1381 }
Ray Strode90e701d2008-12-18 23:05:43 -05001382
Kristian Høgsberge3ef3e52008-12-21 19:30:01 -05001383 device->x = x;
1384 device->y = y;
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -05001385
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001386 if (device->grab) {
1387 interface = device->grab->interface;
1388 interface->motion(device->grab, time, x, y);
1389 } else {
Kristian Høgsberg83fc0612010-08-04 22:44:55 -04001390 es = pick_surface(device, &sx, &sy);
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001391 wl_input_device_set_pointer_focus(device,
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001392 &es->surface,
Kristian Høgsberg26437072010-12-01 10:17:47 -05001393 time, x, y, sx, sy);
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001394 if (device->pointer_focus_resource)
1395 wl_resource_post_event(device->pointer_focus_resource,
1396 WL_INPUT_DEVICE_MOTION,
1397 time, x, y, sx, sy);
Kristian Høgsberg83fc0612010-08-04 22:44:55 -04001398 }
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001399
Kristian Høgsbergb8a98332011-06-23 21:00:04 -04001400 wlsc_surface_damage_below(wd->sprite);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001401
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001402 wd->sprite->x = device->x - wd->hotspot_x;
1403 wd->sprite->y = device->y - wd->hotspot_y;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001404
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001405 wlsc_surface_damage(wd->sprite);
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001406}
1407
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001408WL_EXPORT void
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001409wlsc_surface_activate(struct wlsc_surface *surface,
1410 struct wlsc_input_device *device, uint32_t time)
1411{
1412 wlsc_surface_raise(surface);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001413 wl_input_device_set_keyboard_focus(&device->input_device,
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001414 &surface->surface, time);
1415 wlsc_data_device_set_keyboard_focus(device);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001416}
1417
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001418struct wlsc_binding {
1419 uint32_t key;
1420 uint32_t button;
1421 uint32_t modifier;
1422 wlsc_binding_handler_t handler;
1423 void *data;
1424 struct wl_list link;
1425};
1426
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001427WL_EXPORT void
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001428notify_button(struct wl_input_device *device,
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001429 uint32_t time, int32_t button, int32_t state)
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001430{
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001431 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001432 struct wlsc_compositor *compositor = wd->compositor;
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001433 struct wlsc_binding *b;
1434 struct wlsc_surface *surface =
1435 (struct wlsc_surface *) device->pointer_focus;
Kristian Høgsberg4eaa8302011-09-06 13:41:47 -04001436 int32_t sx, sy;
Kristian Høgsbergea081152010-12-07 08:59:51 -05001437
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001438 if (state)
1439 wlsc_compositor_idle_inhibit(compositor);
1440 else
1441 wlsc_compositor_idle_release(compositor);
1442
Kristian Høgsbergdd4046a2011-01-21 17:00:09 -05001443 if (state && surface && device->grab == NULL) {
Kristian Høgsberg75840622011-09-06 13:48:16 -04001444 compositor->shell->activate(compositor->shell,
1445 surface, wd, time);
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001446 wl_input_device_start_grab(device,
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001447 &device->implicit_grab,
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001448 button, time);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001449 }
Kristian Høgsbergdff2e3c2010-12-07 09:02:09 -05001450
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001451 wl_list_for_each(b, &compositor->binding_list, link) {
1452 if (b->button == button &&
1453 b->modifier == wd->modifier_state && state) {
1454 b->handler(&wd->input_device,
1455 time, 0, button, state, b->data);
1456 break;
1457 }
Benjamin Franzke5a2218a2011-02-01 16:30:31 +01001458 }
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001459
Kristian Høgsbergdd4046a2011-01-21 17:00:09 -05001460 if (device->grab)
1461 device->grab->interface->button(device->grab, time,
1462 button, state);
Kristian Høgsbergdff2e3c2010-12-07 09:02:09 -05001463
Kristian Høgsberg4eaa8302011-09-06 13:41:47 -04001464 if (!state && device->grab && device->grab_button == button) {
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001465 wl_input_device_end_grab(device, time);
Kristian Høgsberg4eaa8302011-09-06 13:41:47 -04001466 surface = pick_surface(device, &sx, &sy);
1467 wl_input_device_set_pointer_focus(device, &surface->surface,
1468 time, device->x, device->y,
1469 sx, sy);
1470 }
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001471}
1472
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001473static void
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001474terminate_binding(struct wl_input_device *device, uint32_t time,
1475 uint32_t key, uint32_t button, uint32_t state, void *data)
Kristian Høgsberg3555d092011-04-11 13:58:13 -04001476{
1477 struct wlsc_compositor *compositor = data;
1478
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001479 if (state)
1480 wl_display_terminate(compositor->wl_display);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04001481}
1482
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001483WL_EXPORT struct wlsc_binding *
Kristian Høgsberg3555d092011-04-11 13:58:13 -04001484wlsc_compositor_add_binding(struct wlsc_compositor *compositor,
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001485 uint32_t key, uint32_t button, uint32_t modifier,
Kristian Høgsberg3555d092011-04-11 13:58:13 -04001486 wlsc_binding_handler_t handler, void *data)
1487{
1488 struct wlsc_binding *binding;
1489
1490 binding = malloc(sizeof *binding);
1491 if (binding == NULL)
1492 return NULL;
1493
1494 binding->key = key;
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001495 binding->button = button;
Kristian Høgsberg3555d092011-04-11 13:58:13 -04001496 binding->modifier = modifier;
1497 binding->handler = handler;
1498 binding->data = data;
1499 wl_list_insert(compositor->binding_list.prev, &binding->link);
1500
1501 return binding;
1502}
1503
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001504WL_EXPORT void
Kristian Høgsberg3555d092011-04-11 13:58:13 -04001505wlsc_binding_destroy(struct wlsc_binding *binding)
1506{
1507 wl_list_remove(&binding->link);
1508 free(binding);
1509}
1510
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001511static void
1512update_modifier_state(struct wlsc_input_device *device,
1513 uint32_t key, uint32_t state)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001514{
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001515 uint32_t modifier;
Kristian Høgsbergab909ae2001-01-01 22:24:24 -05001516
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001517 switch (key) {
1518 case KEY_LEFTCTRL:
1519 case KEY_RIGHTCTRL:
1520 modifier = MODIFIER_CTRL;
1521 break;
1522
1523 case KEY_LEFTALT:
1524 case KEY_RIGHTALT:
1525 modifier = MODIFIER_ALT;
1526 break;
1527
Kristian Høgsberg5b75f1b2010-08-04 23:21:41 -04001528 case KEY_LEFTMETA:
1529 case KEY_RIGHTMETA:
1530 modifier = MODIFIER_SUPER;
1531 break;
1532
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001533 default:
1534 modifier = 0;
1535 break;
1536 }
1537
1538 if (state)
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001539 device->modifier_state |= modifier;
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001540 else
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001541 device->modifier_state &= ~modifier;
1542}
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001543
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001544WL_EXPORT void
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001545notify_key(struct wl_input_device *device,
1546 uint32_t time, uint32_t key, uint32_t state)
1547{
1548 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001549 struct wlsc_compositor *compositor = wd->compositor;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001550 uint32_t *k, *end;
1551 struct wlsc_binding *b;
1552
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001553 if (state)
1554 wlsc_compositor_idle_inhibit(compositor);
1555 else
1556 wlsc_compositor_idle_release(compositor);
1557
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001558 wl_list_for_each(b, &compositor->binding_list, link) {
1559 if (b->key == key &&
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001560 b->modifier == wd->modifier_state) {
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001561 b->handler(&wd->input_device,
1562 time, key, 0, state, b->data);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001563 break;
1564 }
1565 }
1566
1567 update_modifier_state(wd, key, state);
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001568 end = device->keys.data + device->keys.size;
1569 for (k = device->keys.data; k < end; k++) {
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001570 if (*k == key)
1571 *k = *--end;
1572 }
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001573 device->keys.size = (void *) end - device->keys.data;
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001574 if (state) {
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001575 k = wl_array_add(&device->keys, sizeof *k);
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001576 *k = key;
1577 }
Ray Strodee96dcb82008-12-20 02:00:49 -05001578
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001579 if (device->keyboard_focus_resource)
1580 wl_resource_post_event(device->keyboard_focus_resource,
1581 WL_INPUT_DEVICE_KEY, time, key, state);
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001582}
1583
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001584WL_EXPORT void
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001585notify_pointer_focus(struct wl_input_device *device,
1586 uint32_t time, struct wlsc_output *output,
1587 int32_t x, int32_t y)
1588{
1589 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001590 struct wlsc_compositor *compositor = wd->compositor;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001591 struct wlsc_surface *es;
1592 int32_t sx, sy;
1593
1594 if (output) {
1595 device->x = x;
1596 device->y = y;
1597 es = pick_surface(device, &sx, &sy);
1598 wl_input_device_set_pointer_focus(device,
1599 &es->surface,
1600 time, x, y, sx, sy);
1601
1602 compositor->focus = 1;
1603
1604 wd->sprite->x = device->x - wd->hotspot_x;
1605 wd->sprite->y = device->y - wd->hotspot_y;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001606 } else {
1607 wl_input_device_set_pointer_focus(device, NULL,
1608 time, 0, 0, 0, 0);
1609 compositor->focus = 0;
1610 }
1611
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001612 wlsc_surface_damage(wd->sprite);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001613}
1614
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001615WL_EXPORT void
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001616notify_keyboard_focus(struct wl_input_device *device,
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001617 uint32_t time, struct wlsc_output *output,
1618 struct wl_array *keys)
1619{
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001620 struct wlsc_input_device *wd =
1621 (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001622 struct wlsc_compositor *compositor = wd->compositor;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001623 struct wlsc_surface *es;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001624 uint32_t *k, *end;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001625
1626 if (!wl_list_empty(&compositor->surface_list))
1627 es = container_of(compositor->surface_list.next,
1628 struct wlsc_surface, link);
1629 else
1630 es = NULL;
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001631
1632 if (output) {
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001633 wl_array_copy(&wd->input_device.keys, keys);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001634 wd->modifier_state = 0;
1635 end = device->keys.data + device->keys.size;
1636 for (k = device->keys.data; k < end; k++) {
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001637 wlsc_compositor_idle_inhibit(compositor);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001638 update_modifier_state(wd, *k, 1);
1639 }
1640
Kristian Høgsbergf59da392011-09-06 13:44:56 -04001641 if (es && es->surface.resource.client)
Benjamin Franzkeb7c00a42011-06-23 23:30:30 +02001642 wl_input_device_set_keyboard_focus(&wd->input_device,
1643 &es->surface, time);
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001644 } else {
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001645 end = device->keys.data + device->keys.size;
1646 for (k = device->keys.data; k < end; k++)
1647 wlsc_compositor_idle_release(compositor);
1648
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001649 wd->modifier_state = 0;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001650 wl_input_device_set_keyboard_focus(&wd->input_device,
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001651 NULL, time);
1652 }
1653}
1654
1655
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04001656static void
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001657input_device_attach(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001658 struct wl_resource *resource,
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001659 uint32_t time,
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001660 struct wl_resource *buffer_resource, int32_t x, int32_t y)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001661{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001662 struct wlsc_input_device *device = resource->data;
Kristian Høgsberg57295eb2011-08-29 16:02:57 -04001663 struct wl_buffer *buffer;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001664
1665 if (time < device->input_device.pointer_focus_time)
1666 return;
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001667#if 0
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001668 if (device->input_device.pointer_focus == NULL)
1669 return;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001670 if (device->input_device.pointer_focus->resource.client != client)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001671 return;
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001672#endif
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001673
Kristian Høgsberg57295eb2011-08-29 16:02:57 -04001674 if (buffer_resource) {
1675 buffer = buffer_resource->data;
1676 wlsc_input_device_attach_buffer(device, buffer, x, y);
1677 } else {
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001678 wlsc_input_device_set_pointer_image(device,
1679 WLSC_POINTER_LEFT_PTR);
1680 return;
1681 }
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001682}
1683
1684const static struct wl_input_device_interface input_device_interface = {
1685 input_device_attach,
1686};
1687
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001688static void unbind_input_device(struct wl_resource *resource)
1689{
1690 wl_list_remove(&resource->link);
1691 free(resource);
1692}
1693
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001694static void
1695bind_input_device(struct wl_client *client,
1696 void *data, uint32_t version, uint32_t id)
1697{
Kristian Høgsberg8e6d7122011-08-29 16:04:39 -04001698 struct wl_input_device *device = data;
1699 struct wl_resource *resource;
1700
1701 resource = wl_client_add_object(client, &wl_input_device_interface,
1702 &input_device_interface, id, data);
1703 wl_list_insert(&device->resource_list, &resource->link);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001704 resource->destroy = unbind_input_device;
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001705}
1706
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001707WL_EXPORT void
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001708wlsc_input_device_init(struct wlsc_input_device *device,
1709 struct wlsc_compositor *ec)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001710{
Kristian Høgsberga8873122011-11-23 10:39:34 -05001711 wl_input_device_init(&device->input_device);
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001712 wl_list_init(&device->drag_resource_list);
Kristian Høgsberg02ef1c12010-12-06 21:35:19 -05001713
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001714 wl_display_add_global(ec->wl_display, &wl_input_device_interface,
1715 device, bind_input_device);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001716
Kristian Høgsbergc5d6be92011-01-14 16:22:37 -05001717 device->sprite = wlsc_surface_create(ec,
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001718 device->input_device.x,
1719 device->input_device.y, 32, 32);
Kristian Høgsberg8244b442011-06-23 15:44:14 -04001720 wl_list_insert(&ec->surface_list, &device->sprite->link);
1721
Kristian Høgsberga8873122011-11-23 10:39:34 -05001722 device->compositor = ec;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04001723 device->hotspot_x = 16;
1724 device->hotspot_y = 16;
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001725 device->modifier_state = 0;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001726
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001727 device->input_device.implicit_grab.interface = &implicit_grab_interface;
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001728
Kristian Høgsbergc492b482008-12-12 12:00:02 -05001729 wl_list_insert(ec->input_device_list.prev, &device->link);
Kristian Høgsberg1db21f12010-08-16 16:08:12 -04001730
1731 wlsc_input_device_set_pointer_image(device, WLSC_POINTER_LEFT_PTR);
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001732 device->selection_data_source = NULL;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001733}
1734
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001735static void
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001736bind_output(struct wl_client *client,
1737 void *data, uint32_t version, uint32_t id)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05001738{
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001739 struct wlsc_output *output = data;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001740 struct wlsc_mode *mode;
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001741 struct wl_resource *resource;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001742
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001743 resource = wl_client_add_object(client,
1744 &wl_output_interface, NULL, id, data);
1745
1746 wl_resource_post_event(resource,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001747 WL_OUTPUT_GEOMETRY,
1748 output->x,
1749 output->y,
1750 output->mm_width,
1751 output->mm_height,
1752 output->subpixel,
1753 output->make, output->model);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001754
1755 wl_list_for_each (mode, &output->mode_list, link) {
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001756 wl_resource_post_event(resource,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001757 WL_OUTPUT_MODE,
1758 mode->flags,
1759 mode->width,
1760 mode->height,
1761 mode->refresh);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001762 }
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001763}
1764
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001765static const char vertex_shader[] =
1766 "uniform mat4 proj;\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05001767 "attribute vec2 position;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001768 "attribute vec2 texcoord;\n"
1769 "varying vec2 v_texcoord;\n"
1770 "void main()\n"
1771 "{\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05001772 " gl_Position = proj * vec4(position, 0.0, 1.0);\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001773 " v_texcoord = texcoord;\n"
1774 "}\n";
1775
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001776static const char texture_fragment_shader[] =
Kristian Høgsbergdfce71d2010-12-07 20:19:10 -05001777 "precision mediump float;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001778 "varying vec2 v_texcoord;\n"
1779 "uniform sampler2D tex;\n"
1780 "void main()\n"
1781 "{\n"
1782 " gl_FragColor = texture2D(tex, v_texcoord)\n;"
1783 "}\n";
1784
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001785static const char solid_fragment_shader[] =
1786 "precision mediump float;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001787 "uniform vec4 color;\n"
1788 "void main()\n"
1789 "{\n"
1790 " gl_FragColor = color\n;"
1791 "}\n";
1792
Kristian Høgsberga9468212010-06-14 21:03:11 -04001793static int
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001794compile_shader(GLenum type, const char *source)
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001795{
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001796 GLuint s;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001797 char msg[512];
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001798 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001799
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001800 s = glCreateShader(type);
1801 glShaderSource(s, 1, &source, NULL);
1802 glCompileShader(s);
1803 glGetShaderiv(s, GL_COMPILE_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001804 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001805 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
1806 fprintf(stderr, "shader info: %s\n", msg);
1807 return GL_NONE;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001808 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001809
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001810 return s;
1811}
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001812
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001813static int
1814wlsc_shader_init(struct wlsc_shader *shader,
1815 const char *vertex_source, const char *fragment_source)
1816{
1817 char msg[512];
1818 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001819
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001820 shader->vertex_shader =
1821 compile_shader(GL_VERTEX_SHADER, vertex_source);
1822 shader->fragment_shader =
1823 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
1824
1825 shader->program = glCreateProgram();
1826 glAttachShader(shader->program, shader->vertex_shader);
1827 glAttachShader(shader->program, shader->fragment_shader);
1828 glBindAttribLocation(shader->program, 0, "position");
1829 glBindAttribLocation(shader->program, 1, "texcoord");
1830
1831 glLinkProgram(shader->program);
1832 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001833 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001834 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001835 fprintf(stderr, "link info: %s\n", msg);
1836 return -1;
1837 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001838
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001839 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
1840 shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001841
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001842 return 0;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001843}
1844
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001845static int
1846init_solid_shader(struct wlsc_shader *shader,
1847 GLuint vertex_shader, const char *fragment_source)
1848{
1849 GLint status;
1850 char msg[512];
1851
1852 shader->vertex_shader = vertex_shader;
1853 shader->fragment_shader =
1854 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
1855
1856 shader->program = glCreateProgram();
1857 glAttachShader(shader->program, shader->vertex_shader);
1858 glAttachShader(shader->program, shader->fragment_shader);
1859 glBindAttribLocation(shader->program, 0, "position");
1860 glBindAttribLocation(shader->program, 1, "texcoord");
1861
1862 glLinkProgram(shader->program);
1863 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
1864 if (!status) {
1865 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
1866 fprintf(stderr, "link info: %s\n", msg);
1867 return -1;
1868 }
1869
1870 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
1871 shader->color_uniform = glGetUniformLocation(shader->program, "color");
1872
1873 return 0;
1874}
1875
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001876WL_EXPORT void
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001877wlsc_output_destroy(struct wlsc_output *output)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001878{
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04001879 pixman_region32_fini(&output->region);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04001880 pixman_region32_fini(&output->previous_damage);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001881}
1882
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001883WL_EXPORT void
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001884wlsc_output_move(struct wlsc_output *output, int x, int y)
1885{
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01001886 int flip;
1887
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001888 output->x = x;
1889 output->y = y;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001890
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04001891 pixman_region32_init(&output->previous_damage);
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04001892 pixman_region32_init_rect(&output->region, x, y,
1893 output->current->width,
1894 output->current->height);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001895
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001896 wlsc_matrix_init(&output->matrix);
1897 wlsc_matrix_translate(&output->matrix,
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001898 -output->x - output->current->width / 2.0,
1899 -output->y - output->current->height / 2.0, 0);
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01001900
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001901 flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001902 wlsc_matrix_scale(&output->matrix,
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001903 2.0 / output->current->width,
1904 flip * 2.0 / output->current->height, 1);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001905
Kristian Høgsbergd8264042011-11-11 11:48:12 -05001906 wlsc_output_damage(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001907}
1908
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001909WL_EXPORT void
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001910wlsc_output_init(struct wlsc_output *output, struct wlsc_compositor *c,
1911 int x, int y, int width, int height, uint32_t flags)
1912{
1913 output->compositor = c;
1914 output->x = x;
1915 output->y = y;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001916 output->mm_width = width;
1917 output->mm_height = height;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001918
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001919 output->flags = flags;
1920 wlsc_output_move(output, x, y);
1921
Benjamin Franzke06286262011-05-06 19:12:33 +02001922 output->scanout_buffer_destroy_listener.func =
1923 output_handle_scanout_buffer_destroy;
Kristian Høgsberg191454e2011-10-20 17:51:45 -04001924 output->pending_scanout_buffer_destroy_listener.func =
1925 output_handle_pending_scanout_buffer_destroy;
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +03001926
Kristian Høgsberg33418202011-08-16 23:01:28 -04001927 wl_list_init(&output->frame_callback_list);
Benjamin Franzke06286262011-05-06 19:12:33 +02001928
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001929 wl_display_add_global(c->wl_display,
1930 &wl_output_interface, output, bind_output);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001931}
1932
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001933static void
1934shm_buffer_created(struct wl_buffer *buffer)
1935{
1936 struct wl_list *surfaces_attached_to;
1937
1938 surfaces_attached_to = malloc(sizeof *surfaces_attached_to);
1939 if (!surfaces_attached_to) {
1940 buffer->user_data = NULL;
1941 return;
1942 }
1943
1944 wl_list_init(surfaces_attached_to);
1945
1946 buffer->user_data = surfaces_attached_to;
1947}
1948
1949static void
1950shm_buffer_damaged(struct wl_buffer *buffer,
1951 int32_t x, int32_t y, int32_t width, int32_t height)
1952{
1953 struct wl_list *surfaces_attached_to = buffer->user_data;
1954 struct wlsc_surface *es;
Benjamin Franzkefab5ec12011-04-25 19:44:47 +02001955 GLsizei tex_width = wl_shm_buffer_get_stride(buffer) / 4;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001956
1957 wl_list_for_each(es, surfaces_attached_to, buffer_link) {
1958 glBindTexture(GL_TEXTURE_2D, es->texture);
1959 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Benjamin Franzkefab5ec12011-04-25 19:44:47 +02001960 tex_width, buffer->height, 0,
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001961 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1962 wl_shm_buffer_get_data(buffer));
1963 /* Hmm, should use glTexSubImage2D() here but GLES2 doesn't
1964 * support any unpack attributes except GL_UNPACK_ALIGNMENT. */
1965 }
1966}
1967
1968static void
1969shm_buffer_destroyed(struct wl_buffer *buffer)
1970{
1971 struct wl_list *surfaces_attached_to = buffer->user_data;
1972 struct wlsc_surface *es, *next;
1973
1974 wl_list_for_each_safe(es, next, surfaces_attached_to, buffer_link) {
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001975 wl_list_remove(&es->buffer_link);
Kristian Høgsbergfac11d22011-05-02 13:35:17 -04001976 wl_list_init(&es->buffer_link);
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001977 }
1978
1979 free(surfaces_attached_to);
1980}
1981
1982const static struct wl_shm_callbacks shm_callbacks = {
1983 shm_buffer_created,
1984 shm_buffer_damaged,
1985 shm_buffer_destroyed
1986};
1987
Kristian Høgsberga8873122011-11-23 10:39:34 -05001988static void
1989compositor_bind(struct wl_client *client,
1990 void *data, uint32_t version, uint32_t id)
1991{
1992 struct wlsc_compositor *compositor = data;
1993
1994 wl_client_add_object(client, &wl_compositor_interface,
1995 &compositor_interface, id, compositor);
1996}
1997
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001998WL_EXPORT int
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001999wlsc_compositor_init(struct wlsc_compositor *ec, struct wl_display *display)
2000{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05002001 struct wl_event_loop *loop;
Kristian Høgsbergd711d0c2011-01-14 17:28:21 -05002002 const char *extensions;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002003
Kristian Høgsbergf9212892008-10-11 18:40:23 -04002004 ec->wl_display = display;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002005
Kristian Høgsberga8873122011-11-23 10:39:34 -05002006 if (!wl_display_add_global(display, &wl_compositor_interface,
2007 ec, compositor_bind))
2008 return -1;
Kristian Høgsbergee02ca62008-12-21 23:37:12 -05002009
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002010 ec->shm = wl_shm_init(display, &shm_callbacks);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002011
2012 ec->image_target_texture_2d =
2013 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
2014 ec->image_target_renderbuffer_storage = (void *)
2015 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
2016 ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
2017 ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
2018 ec->bind_display =
2019 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
2020 ec->unbind_display =
2021 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
2022
2023 extensions = (const char *) glGetString(GL_EXTENSIONS);
2024 if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
2025 fprintf(stderr,
2026 "GL_EXT_texture_format_BGRA8888 not available\n");
2027 return -1;
2028 }
2029
2030 extensions =
2031 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
2032 if (strstr(extensions, "EGL_WL_bind_wayland_display"))
2033 ec->has_bind_display = 1;
2034 if (ec->has_bind_display)
2035 ec->bind_display(ec->display, ec->wl_display);
Kristian Høgsberg3d5bae02010-10-06 21:17:40 -04002036
Kristian Høgsberg201a9042008-12-10 00:40:50 -05002037 wl_list_init(&ec->surface_list);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002038 wl_list_init(&ec->input_device_list);
2039 wl_list_init(&ec->output_list);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04002040 wl_list_init(&ec->binding_list);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002041 wl_list_init(&ec->animation_list);
Kristian Høgsbergd3ef7be2011-10-29 15:04:42 -04002042 wlsc_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002043 ec->fade.animation.frame = fade_frame;
2044 wl_list_init(&ec->fade.animation.link);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04002045
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04002046 wlsc_compositor_add_binding(ec, KEY_BACKSPACE, 0,
Kristian Høgsberg3555d092011-04-11 13:58:13 -04002047 MODIFIER_CTRL | MODIFIER_ALT,
2048 terminate_binding, ec);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002049
Kristian Høgsberg1db21f12010-08-16 16:08:12 -04002050 create_pointer_images(ec);
2051
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002052 screenshooter_create(ec);
2053
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002054 wlsc_data_device_manager_init(ec);
2055
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002056 glActiveTexture(GL_TEXTURE0);
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002057
2058 if (wlsc_shader_init(&ec->texture_shader,
2059 vertex_shader, texture_fragment_shader) < 0)
Kristian Høgsberga9468212010-06-14 21:03:11 -04002060 return -1;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002061 if (init_solid_shader(&ec->solid_shader,
2062 ec->texture_shader.vertex_shader,
2063 solid_fragment_shader) < 0)
2064 return -1;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05002065
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05002066 loop = wl_display_get_event_loop(ec->wl_display);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002067 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
2068 wl_event_source_timer_update(ec->idle_source, option_idle_time * 1000);
2069
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -04002070 wlsc_compositor_schedule_repaint(ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04002071
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002072 return 0;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002073}
2074
Benjamin Franzkeb8263022011-08-30 11:32:47 +02002075WL_EXPORT void
Matt Roper361d2ad2011-08-29 13:52:23 -07002076wlsc_compositor_shutdown(struct wlsc_compositor *ec)
2077{
2078 struct wlsc_output *output;
2079
2080 /* Destroy all outputs associated with this compositor */
2081 wl_list_for_each(output, &ec->output_list, link)
2082 output->destroy(output);
2083}
2084
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002085static int on_term_signal(int signal_number, void *data)
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002086{
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04002087 struct wl_display *display = data;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002088
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002089 fprintf(stderr, "caught signal %d\n", signal_number);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04002090 wl_display_terminate(display);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002091
2092 return 1;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002093}
2094
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002095static void *
2096load_module(const char *name, const char *entrypoint, void **handle)
2097{
2098 char path[PATH_MAX];
2099 void *module, *init;
2100
2101 if (name[0] != '/')
2102 snprintf(path, sizeof path, MODULEDIR "/%s", name);
2103 else
Benjamin Franzkeb7acce62011-05-06 23:19:22 +02002104 snprintf(path, sizeof path, "%s", name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002105
2106 module = dlopen(path, RTLD_LAZY);
2107 if (!module) {
2108 fprintf(stderr,
2109 "failed to load module: %s\n", dlerror());
2110 return NULL;
2111 }
2112
2113 init = dlsym(module, entrypoint);
2114 if (!init) {
2115 fprintf(stderr,
2116 "failed to lookup init function: %s\n", dlerror());
2117 return NULL;
2118 }
2119
2120 return init;
2121}
2122
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002123int main(int argc, char *argv[])
2124{
2125 struct wl_display *display;
Kristian Høgsberg8e438622009-01-26 23:07:00 -05002126 struct wlsc_compositor *ec;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002127 struct wl_event_loop *loop;
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002128 int o, xserver = 0;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002129 void *shell_module, *backend_module;
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04002130 int (*shell_init)(struct wlsc_compositor *ec);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002131 struct wlsc_compositor
2132 *(*backend_init)(struct wl_display *display, char *options);
2133 char *backend = NULL;
2134 char *backend_options = "";
2135 char *shell = NULL;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002136 char *p;
2137
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002138 static const char opts[] = "B:b:o:S:i:s:x";
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002139 static const struct option longopts[ ] = {
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002140 { "backend", 1, NULL, 'B' },
2141 { "backend-options", 1, NULL, 'o' },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002142 { "socket", 1, NULL, 'S' },
2143 { "idle-time", 1, NULL, 'i' },
2144 { "shell", 1, NULL, 's' },
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002145 { "xserver", 0, NULL, 'x' },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002146 { NULL, }
2147 };
Kristian Høgsbergd6531262008-12-12 11:06:18 -05002148
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002149 while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) {
2150 switch (o) {
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002151 case 'B':
2152 backend = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002153 break;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002154 case 'o':
2155 backend_options = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002156 break;
2157 case 'S':
2158 option_socket_name = optarg;
2159 break;
2160 case 'i':
2161 option_idle_time = strtol(optarg, &p, 0);
2162 if (*p != '\0') {
2163 fprintf(stderr,
2164 "invalid idle time option: %s\n",
2165 optarg);
2166 exit(EXIT_FAILURE);
2167 }
2168 break;
2169 case 's':
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002170 shell = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002171 break;
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002172 case 'x':
2173 xserver = 1;
2174 break;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002175 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04002176 }
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002177
2178 display = wl_display_create();
2179
Tiago Vignatti2116b892011-08-08 05:52:59 -07002180 loop = wl_display_get_event_loop(display);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04002181 wl_event_loop_add_signal(loop, SIGTERM, on_term_signal, display);
2182 wl_event_loop_add_signal(loop, SIGINT, on_term_signal, display);
2183 wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal, display);
Tiago Vignatti2116b892011-08-08 05:52:59 -07002184
2185 wl_list_init(&child_process_list);
2186 wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler, NULL);
Kristian Høgsberga9410222011-01-14 17:22:35 -05002187
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002188 if (!backend) {
2189 if (getenv("WAYLAND_DISPLAY"))
2190 backend = "wayland-backend.so";
2191 else if (getenv("DISPLAY"))
2192 backend = "x11-backend.so";
2193 else if (getenv("OPENWFD"))
2194 backend = "openwfd-backend.so";
2195 else
2196 backend = "drm-backend.so";
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04002197 }
2198
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002199 if (!shell)
2200 shell = "desktop-shell.so";
Kristian Høgsberga9410222011-01-14 17:22:35 -05002201
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002202 backend_init = load_module(backend, "backend_init", &backend_module);
2203 if (!backend_init)
2204 exit(EXIT_FAILURE);
Kristian Høgsberga9410222011-01-14 17:22:35 -05002205
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002206 shell_init = load_module(shell, "shell_init", &shell_module);
2207 if (!shell_init)
2208 exit(EXIT_FAILURE);
Benjamin Franzke5d007092011-04-04 00:30:25 +02002209
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002210 ec = backend_init(display, backend_options);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05002211 if (ec == NULL) {
2212 fprintf(stderr, "failed to create compositor\n");
2213 exit(EXIT_FAILURE);
2214 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04002215
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04002216 if (shell_init(ec) < 0)
2217 exit(EXIT_FAILURE);
2218
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002219 if (xserver)
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002220 wlsc_xserver_init(ec);
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002221
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05002222 if (wl_display_add_socket(display, option_socket_name)) {
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002223 fprintf(stderr, "failed to add socket: %m\n");
2224 exit(EXIT_FAILURE);
2225 }
2226
2227 wl_display_run(display);
2228
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002229 if (xserver)
2230 wlsc_xserver_destroy(ec);
2231
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002232 if (ec->has_bind_display)
2233 ec->unbind_display(ec->display, display);
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05002234 wl_display_destroy(display);
2235
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002236 ec->destroy(ec);
2237
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002238 return 0;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002239}