2 * Copyright © 2010-2011 Intel Corporation
3 * Copyright © 2008-2011 Kristian Høgsberg
4 * Copyright © 2012 Collabora, Ltd.
6 * Permission to use, copy, modify, distribute, and sell this software and
7 * its documentation for any purpose is hereby granted without fee, provided
8 * that the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of the copyright holders not be used in
11 * advertising or publicity pertaining to distribution of the software
12 * without specific, written prior permission. The copyright holders make
13 * no representations about the suitability of this software for any
14 * purpose. It is provided "as is" without express or implied warranty.
16 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
17 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
18 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
19 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
20 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
21 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
22 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
36 #include <sys/ioctl.h>
38 #include <sys/types.h>
39 #include <sys/socket.h>
43 #include <linux/input.h>
50 #include <wayland-server.h>
51 #include "compositor.h"
53 static const char *option_socket_name = NULL;
55 static struct wl_list child_process_list;
56 static jmp_buf segv_jmp_buf;
59 sigchld_handler(int signal_number, void *data)
61 struct weston_process *p;
66 wl_list_for_each(p, &child_process_list, link) {
71 if (&p->link == &child_process_list) {
72 fprintf(stderr, "unknown child process exited\n");
76 wl_list_remove(&p->link);
77 p->cleanup(p, status);
83 weston_watch_process(struct weston_process *process)
85 wl_list_insert(&child_process_list, &process->link);
89 child_client_exec(int sockfd, const char *path)
95 /* do not give our signal mask to the new process */
97 sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
99 /* Launch clients as the user. */
102 /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
103 * non-CLOEXEC fd to pass through exec. */
104 clientfd = dup(sockfd);
105 if (clientfd == -1) {
106 fprintf(stderr, "compositor: dup failed: %m\n");
110 snprintf(s, sizeof s, "%d", clientfd);
111 setenv("WAYLAND_SOCKET", s, 1);
113 if (execl(path, path, NULL) < 0)
114 fprintf(stderr, "compositor: executing '%s' failed: %m\n",
118 WL_EXPORT struct wl_client *
119 weston_client_launch(struct weston_compositor *compositor,
120 struct weston_process *proc,
122 weston_process_cleanup_func_t cleanup)
126 struct wl_client *client;
128 if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {
129 fprintf(stderr, "weston_client_launch: "
130 "socketpair failed while launching '%s': %m\n",
139 fprintf(stderr, "weston_client_launch: "
140 "fork failed while launching '%s': %m\n", path);
145 child_client_exec(sv[1], path);
151 client = wl_client_create(compositor->wl_display, sv[0]);
154 fprintf(stderr, "weston_client_launch: "
155 "wl_client_create failed while launching '%s'.\n",
161 proc->cleanup = cleanup;
162 weston_watch_process(proc);
168 surface_handle_buffer_destroy(struct wl_listener *listener,
169 struct wl_resource *resource, uint32_t time)
171 struct weston_surface *es =
172 container_of(listener, struct weston_surface,
173 buffer_destroy_listener);
178 WL_EXPORT struct weston_surface *
179 weston_surface_create(struct weston_compositor *compositor)
181 struct weston_surface *surface;
183 surface = calloc(1, sizeof *surface);
187 wl_list_init(&surface->link);
188 wl_list_init(&surface->buffer_link);
190 surface->surface.resource.client = NULL;
192 surface->compositor = compositor;
193 surface->visual = WESTON_NONE_VISUAL;
194 surface->image = EGL_NO_IMAGE_KHR;
195 surface->alpha = 255;
197 surface->fullscreen_output = NULL;
198 surface->buffer = NULL;
199 surface->output = NULL;
201 pixman_region32_init(&surface->damage);
202 pixman_region32_init(&surface->transform.opaque);
203 wl_list_init(&surface->frame_callback_list);
205 surface->buffer_destroy_listener.func = surface_handle_buffer_destroy;
207 wl_list_init(&surface->geometry.transformation_list);
208 wl_list_insert(&surface->geometry.transformation_list,
209 &surface->transform.position.link);
210 weston_matrix_init(&surface->transform.position.matrix);
211 pixman_region32_init(&surface->transform.boundingbox);
212 surface->geometry.dirty = 1;
218 weston_surface_set_color(struct weston_surface *surface,
219 GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
222 surface->visual = WESTON_RGB_VISUAL;
224 surface->visual = WESTON_ARGB_VISUAL;
226 surface->color[0] = red;
227 surface->color[1] = green;
228 surface->color[2] = blue;
229 surface->color[3] = alpha;
230 surface->shader = &surface->compositor->solid_shader;
234 surface_to_global_float(struct weston_surface *surface,
235 int32_t sx, int32_t sy, GLfloat *x, GLfloat *y)
237 if (surface->transform.enabled) {
238 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
240 weston_matrix_transform(&surface->transform.matrix, &v);
242 if (fabsf(v.f[3]) < 1e-6) {
243 fprintf(stderr, "warning: numerical instability in "
244 "weston_surface_to_global(), divisor = %g\n",
251 *x = v.f[0] / v.f[3];
252 *y = v.f[1] / v.f[3];
254 *x = sx + surface->geometry.x;
255 *y = sy + surface->geometry.y;
260 weston_surface_damage_below_noupdate(struct weston_surface *surface)
262 struct weston_surface *below;
264 if (surface->output == NULL)
267 if (surface->link.next == &surface->compositor->surface_list)
270 below = container_of(surface->link.next, struct weston_surface, link);
271 pixman_region32_union(&below->damage, &below->damage,
272 &surface->transform.boundingbox);
276 surface_compute_bbox(struct weston_surface *surface, int32_t sx, int32_t sy,
277 int32_t width, int32_t height,
278 pixman_region32_t *bbox)
280 GLfloat min_x = HUGE_VALF, min_y = HUGE_VALF;
281 GLfloat max_x = -HUGE_VALF, max_y = -HUGE_VALF;
286 { sx + width, sy + height }
288 GLfloat int_x, int_y;
291 for (i = 0; i < 4; ++i) {
293 surface_to_global_float(surface, s[i][0], s[i][1], &x, &y);
304 int_x = floorf(min_x);
305 int_y = floorf(min_y);
306 pixman_region32_init_rect(bbox, int_x, int_y,
307 ceilf(max_x) - int_x, ceilf(max_y) - int_y);
311 weston_surface_update_transform_disable(struct weston_surface *surface)
313 surface->transform.enabled = 0;
315 /* round off fractions when not transformed */
316 surface->geometry.x = roundf(surface->geometry.x);
317 surface->geometry.y = roundf(surface->geometry.y);
319 pixman_region32_init_rect(&surface->transform.boundingbox,
322 surface->geometry.width,
323 surface->geometry.height);
327 weston_surface_update_transform_enable(struct weston_surface *surface)
329 struct weston_matrix *matrix = &surface->transform.matrix;
330 struct weston_matrix *inverse = &surface->transform.inverse;
331 struct weston_transform *tform;
333 surface->transform.enabled = 1;
335 /* Otherwise identity matrix, but with x and y translation. */
336 surface->transform.position.matrix.d[12] = surface->geometry.x;
337 surface->transform.position.matrix.d[13] = surface->geometry.y;
339 weston_matrix_init(matrix);
340 wl_list_for_each(tform, &surface->geometry.transformation_list, link)
341 weston_matrix_multiply(matrix, &tform->matrix);
343 if (weston_matrix_invert(inverse, matrix) < 0) {
344 /* Oops, bad total transformation, not invertible */
345 fprintf(stderr, "error: weston_surface %p"
346 " transformation not invertible.\n", surface);
350 surface_compute_bbox(surface, 0, 0, surface->geometry.width,
351 surface->geometry.height,
352 &surface->transform.boundingbox);
357 weston_surface_update_transform(struct weston_surface *surface)
359 if (!surface->geometry.dirty)
362 surface->geometry.dirty = 0;
364 weston_surface_damage_below_noupdate(surface);
366 pixman_region32_fini(&surface->transform.boundingbox);
368 /* transform.position is always in transformation_list */
369 if (surface->geometry.transformation_list.next ==
370 &surface->transform.position.link &&
371 surface->geometry.transformation_list.prev ==
372 &surface->transform.position.link) {
373 weston_surface_update_transform_disable(surface);
375 if (weston_surface_update_transform_enable(surface) < 0)
376 weston_surface_update_transform_disable(surface);
379 /* weston_surface_damage() without update */
380 pixman_region32_union(&surface->damage, &surface->damage,
381 &surface->transform.boundingbox);
383 pixman_region32_fini(&surface->transform.opaque);
384 if (surface->visual == WESTON_RGB_VISUAL &&
385 surface->transform.enabled == 0)
386 pixman_region32_init_rect(&surface->transform.opaque,
389 surface->geometry.width,
390 surface->geometry.height);
392 pixman_region32_init(&surface->transform.opaque);
396 weston_surface_assign_output(surface);
398 weston_compositor_schedule_repaint(surface->compositor);
402 weston_surface_to_global(struct weston_surface *surface,
403 int32_t sx, int32_t sy, int32_t *x, int32_t *y)
407 weston_surface_update_transform(surface);
409 surface_to_global_float(surface, sx, sy, &xf, &yf);
415 surface_from_global_float(struct weston_surface *surface,
416 int32_t x, int32_t y, GLfloat *sx, GLfloat *sy)
418 if (surface->transform.enabled) {
419 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
421 weston_matrix_transform(&surface->transform.inverse, &v);
423 if (fabsf(v.f[3]) < 1e-6) {
424 fprintf(stderr, "warning: numerical instability in "
425 "weston_surface_from_global(), divisor = %g\n",
432 *sx = v.f[0] / v.f[3];
433 *sy = v.f[1] / v.f[3];
435 *sx = x - surface->geometry.x;
436 *sy = y - surface->geometry.y;
441 weston_surface_from_global(struct weston_surface *surface,
442 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
446 weston_surface_update_transform(surface);
448 surface_from_global_float(surface, x, y, &sxf, &syf);
454 weston_surface_damage_rectangle(struct weston_surface *surface,
455 int32_t sx, int32_t sy,
456 int32_t width, int32_t height)
458 weston_surface_update_transform(surface);
460 if (surface->transform.enabled) {
461 pixman_region32_t box;
462 surface_compute_bbox(surface, sx, sy, width, height, &box);
463 pixman_region32_union(&surface->damage, &surface->damage,
465 pixman_region32_fini(&box);
467 pixman_region32_union_rect(&surface->damage, &surface->damage,
468 surface->geometry.x + sx,
469 surface->geometry.y + sy,
473 weston_compositor_schedule_repaint(surface->compositor);
477 weston_surface_damage(struct weston_surface *surface)
479 weston_surface_update_transform(surface);
481 pixman_region32_union(&surface->damage, &surface->damage,
482 &surface->transform.boundingbox);
484 weston_compositor_schedule_repaint(surface->compositor);
488 weston_surface_damage_below(struct weston_surface *surface)
490 weston_surface_update_transform(surface);
491 weston_surface_damage_below_noupdate(surface);
492 weston_compositor_schedule_repaint(surface->compositor);
496 weston_surface_flush_damage(struct weston_surface *surface)
498 struct weston_surface *below;
500 if (surface->output &&
501 surface->link.next != &surface->compositor->surface_list) {
502 below = container_of(surface->link.next,
503 struct weston_surface, link);
505 pixman_region32_union(&below->damage,
506 &below->damage, &surface->damage);
511 weston_surface_configure(struct weston_surface *surface,
512 GLfloat x, GLfloat y, int width, int height)
514 surface->geometry.x = x;
515 surface->geometry.y = y;
516 surface->geometry.width = width;
517 surface->geometry.height = height;
518 surface->geometry.dirty = 1;
522 weston_surface_set_position(struct weston_surface *surface,
523 GLfloat x, GLfloat y)
525 surface->geometry.x = x;
526 surface->geometry.y = y;
527 surface->geometry.dirty = 1;
531 weston_compositor_get_time(void)
535 gettimeofday(&tv, NULL);
537 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
540 static struct weston_surface *
541 weston_compositor_pick_surface(struct weston_compositor *compositor,
542 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
544 struct weston_surface *surface;
546 wl_list_for_each(surface, &compositor->surface_list, link) {
547 if (surface->surface.resource.client == NULL)
549 weston_surface_from_global(surface, x, y, sx, sy);
550 if (0 <= *sx && *sx < surface->geometry.width &&
551 0 <= *sy && *sy < surface->geometry.height)
559 weston_device_repick(struct wl_input_device *device, uint32_t time)
561 struct weston_input_device *wd = (struct weston_input_device *) device;
562 const struct wl_grab_interface *interface;
563 struct weston_surface *surface, *focus;
565 surface = weston_compositor_pick_surface(wd->compositor,
566 device->x, device->y,
570 if (&surface->surface != device->current) {
571 interface = device->grab->interface;
572 interface->focus(device->grab, time, &surface->surface,
573 device->current_x, device->current_y);
574 device->current = &surface->surface;
577 focus = (struct weston_surface *) device->grab->focus;
579 weston_surface_from_global(focus, device->x, device->y,
580 &device->grab->x, &device->grab->y);
584 weston_compositor_repick(struct weston_compositor *compositor)
586 struct weston_input_device *device;
589 if (!compositor->focus)
592 time = weston_compositor_get_time();
593 wl_list_for_each(device, &compositor->input_device_list, link)
594 weston_device_repick(&device->input_device, time);
598 destroy_surface(struct wl_resource *resource)
600 struct weston_surface *surface =
601 container_of(resource,
602 struct weston_surface, surface.resource);
603 struct weston_compositor *compositor = surface->compositor;
605 if (surface->output) {
606 weston_surface_damage_below(surface);
607 weston_surface_flush_damage(surface);
609 wl_list_remove(&surface->link);
610 weston_compositor_repick(compositor);
613 glDeleteTextures(1, &surface->texture);
616 wl_list_remove(&surface->buffer_destroy_listener.link);
618 if (surface->image != EGL_NO_IMAGE_KHR)
619 compositor->destroy_image(compositor->display,
622 wl_list_remove(&surface->buffer_link);
624 pixman_region32_fini(&surface->transform.boundingbox);
625 pixman_region32_fini(&surface->damage);
626 pixman_region32_fini(&surface->transform.opaque);
632 weston_buffer_attach(struct wl_buffer *buffer, struct wl_surface *surface)
634 struct weston_surface *es = (struct weston_surface *) surface;
635 struct weston_compositor *ec = es->compositor;
636 struct wl_list *surfaces_attached_to;
639 glGenTextures(1, &es->texture);
640 glBindTexture(GL_TEXTURE_2D, es->texture);
641 glTexParameteri(GL_TEXTURE_2D,
642 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
643 glTexParameteri(GL_TEXTURE_2D,
644 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
645 es->shader = &ec->texture_shader;
647 glBindTexture(GL_TEXTURE_2D, es->texture);
650 if (wl_buffer_is_shm(buffer)) {
651 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
652 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
653 es->pitch, buffer->height, 0,
654 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
655 wl_shm_buffer_get_data(buffer));
657 switch (wl_shm_buffer_get_format(buffer)) {
658 case WL_SHM_FORMAT_ARGB8888:
659 es->visual = WESTON_ARGB_VISUAL;
661 case WL_SHM_FORMAT_XRGB8888:
662 es->visual = WESTON_RGB_VISUAL;
666 surfaces_attached_to = buffer->user_data;
668 wl_list_remove(&es->buffer_link);
669 wl_list_insert(surfaces_attached_to, &es->buffer_link);
671 if (es->image != EGL_NO_IMAGE_KHR)
672 ec->destroy_image(ec->display, es->image);
673 es->image = ec->create_image(ec->display, NULL,
674 EGL_WAYLAND_BUFFER_WL,
677 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
679 es->visual = WESTON_ARGB_VISUAL;
680 es->pitch = es->geometry.width;
685 texture_region(struct weston_surface *es, pixman_region32_t *region)
687 struct weston_compositor *ec = es->compositor;
688 GLfloat *v, inv_width, inv_height;
690 pixman_box32_t *rectangles;
694 rectangles = pixman_region32_rectangles(region, &n);
695 v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
696 p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
697 inv_width = 1.0 / es->pitch;
698 inv_height = 1.0 / es->geometry.height;
700 for (i = 0; i < n; i++, v += 16, p += 6) {
701 surface_from_global_float(es, rectangles[i].x1,
702 rectangles[i].y1, &sx, &sy);
703 v[ 0] = rectangles[i].x1;
704 v[ 1] = rectangles[i].y1;
705 v[ 2] = sx * inv_width;
706 v[ 3] = sy * inv_height;
708 surface_from_global_float(es, rectangles[i].x1,
709 rectangles[i].y2, &sx, &sy);
710 v[ 4] = rectangles[i].x1;
711 v[ 5] = rectangles[i].y2;
712 v[ 6] = sx * inv_width;
713 v[ 7] = sy * inv_height;
715 surface_from_global_float(es, rectangles[i].x2,
716 rectangles[i].y1, &sx, &sy);
717 v[ 8] = rectangles[i].x2;
718 v[ 9] = rectangles[i].y1;
719 v[10] = sx * inv_width;
720 v[11] = sy * inv_height;
722 surface_from_global_float(es, rectangles[i].x2,
723 rectangles[i].y2, &sx, &sy);
724 v[12] = rectangles[i].x2;
725 v[13] = rectangles[i].y2;
726 v[14] = sx * inv_width;
727 v[15] = sy * inv_height;
741 weston_surface_draw(struct weston_surface *es, struct weston_output *output)
743 struct weston_compositor *ec = es->compositor;
745 pixman_region32_t repaint;
749 pixman_region32_init(&repaint);
750 pixman_region32_intersect(&repaint, &es->transform.boundingbox,
752 pixman_region32_intersect(&repaint, &repaint, &es->damage);
754 /* Clear damage, assume outputs do not overlap. */
755 pixman_region32_subtract(&es->damage, &es->damage, &output->region);
757 if (!pixman_region32_not_empty(&repaint))
760 switch (es->visual) {
761 case WESTON_ARGB_VISUAL:
762 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
765 case WESTON_RGB_VISUAL:
769 fprintf(stderr, "bogus visual\n");
773 if (ec->current_shader != es->shader) {
774 glUseProgram(es->shader->program);
775 ec->current_shader = es->shader;
778 glUniformMatrix4fv(es->shader->proj_uniform,
779 1, GL_FALSE, output->matrix.d);
780 glUniform1i(es->shader->tex_uniform, 0);
781 glUniform4fv(es->shader->color_uniform, 1, es->color);
782 glUniform1f(es->shader->alpha_uniform, es->alpha / 255.0);
783 glUniform1f(es->shader->texwidth_uniform,
784 (GLfloat)es->geometry.width / es->pitch);
786 if (es->transform.enabled)
791 n = texture_region(es, &repaint);
793 glBindTexture(GL_TEXTURE_2D, es->texture);
794 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
795 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
797 v = ec->vertices.data;
798 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
799 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
800 glEnableVertexAttribArray(0);
801 glEnableVertexAttribArray(1);
803 glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
805 glDisableVertexAttribArray(1);
806 glDisableVertexAttribArray(0);
808 ec->vertices.size = 0;
809 ec->indices.size = 0;
812 pixman_region32_fini(&repaint);
815 WL_EXPORT struct wl_list *
816 weston_compositor_top(struct weston_compositor *compositor)
818 struct weston_input_device *input_device;
819 struct wl_list *list;
821 input_device = (struct weston_input_device *) compositor->input_device;
823 /* Insert below pointer */
824 list = &compositor->surface_list;
825 if (compositor->fade.surface &&
826 list->next == &compositor->fade.surface->link)
828 if (list->next == &input_device->sprite->link)
835 weston_surface_raise(struct weston_surface *surface)
837 struct weston_compositor *compositor = surface->compositor;
838 struct wl_list *list = weston_compositor_top(compositor);
840 wl_list_remove(&surface->link);
841 wl_list_insert(list, &surface->link);
842 weston_compositor_repick(compositor);
843 weston_surface_damage(surface);
847 weston_compositor_damage_all(struct weston_compositor *compositor)
849 struct weston_output *output;
851 wl_list_for_each(output, &compositor->output_list, link)
852 weston_output_damage(output);
856 weston_buffer_post_release(struct wl_buffer *buffer)
858 if (--buffer->busy_count > 0)
861 assert(buffer->resource.client != NULL);
862 wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
866 weston_output_damage(struct weston_output *output)
868 struct weston_compositor *compositor = output->compositor;
869 struct weston_surface *es;
871 if (wl_list_empty(&compositor->surface_list))
874 es = container_of(compositor->surface_list.next,
875 struct weston_surface, link);
876 pixman_region32_union(&es->damage, &es->damage, &output->region);
877 weston_compositor_schedule_repaint(compositor);
881 fade_frame(struct weston_animation *animation,
882 struct weston_output *output, uint32_t msecs)
884 struct weston_compositor *compositor =
885 container_of(animation,
886 struct weston_compositor, fade.animation);
887 struct weston_surface *surface;
889 surface = compositor->fade.surface;
890 weston_spring_update(&compositor->fade.spring, msecs);
891 weston_surface_set_color(surface, 0.0, 0.0, 0.0,
892 compositor->fade.spring.current);
893 weston_surface_damage(surface);
895 if (weston_spring_done(&compositor->fade.spring)) {
896 compositor->fade.spring.current =
897 compositor->fade.spring.target;
898 wl_list_remove(&animation->link);
899 wl_list_init(&animation->link);
901 if (compositor->fade.spring.current < 0.001) {
902 destroy_surface(&surface->surface.resource);
903 compositor->fade.surface = NULL;
904 } else if (compositor->fade.spring.current > 0.999) {
905 compositor->state = WESTON_COMPOSITOR_SLEEPING;
906 compositor->shell->lock(compositor->shell);
912 weston_output_set_cursor(struct weston_output *output,
913 struct wl_input_device *dev)
915 struct weston_input_device *device =
916 (struct weston_input_device *) dev;
917 pixman_region32_t cursor_region;
918 int prior_was_hardware;
920 if (device->sprite == NULL)
923 pixman_region32_init(&cursor_region);
924 pixman_region32_intersect(&cursor_region,
925 &device->sprite->transform.boundingbox,
928 if (!pixman_region32_not_empty(&cursor_region)) {
929 output->set_hardware_cursor(output, NULL);
933 prior_was_hardware = device->hw_cursor;
934 if (device->sprite->overlapped ||
935 output->set_hardware_cursor(output, device) < 0) {
936 if (prior_was_hardware) {
937 weston_surface_damage(device->sprite);
938 output->set_hardware_cursor(output, NULL);
940 device->hw_cursor = 0;
942 if (!prior_was_hardware)
943 weston_surface_damage_below(device->sprite);
944 pixman_region32_fini(&device->sprite->damage);
945 pixman_region32_init(&device->sprite->damage);
946 device->hw_cursor = 1;
950 pixman_region32_fini(&cursor_region);
953 struct weston_frame_callback {
954 struct wl_resource resource;
959 weston_output_repaint(struct weston_output *output, int msecs)
961 struct weston_compositor *ec = output->compositor;
962 struct weston_surface *es;
963 struct weston_animation *animation, *next;
964 struct weston_frame_callback *cb, *cnext;
965 pixman_region32_t opaque, new_damage, total_damage,
966 overlap, surface_overlap;
967 int32_t width, height;
969 width = output->current->width +
970 output->border.left + output->border.right;
971 height = output->current->height +
972 output->border.top + output->border.bottom;
973 glViewport(0, 0, width, height);
975 pixman_region32_init(&new_damage);
976 pixman_region32_init(&opaque);
977 pixman_region32_init(&overlap);
979 wl_list_for_each(es, &ec->surface_list, link) {
980 /* Update surface transform now to avoid calling it ever
981 * again from the repaint sub-functions. */
982 weston_surface_update_transform(es);
984 pixman_region32_init(&surface_overlap);
985 pixman_region32_intersect(&surface_overlap, &overlap,
986 &es->transform.boundingbox);
987 es->overlapped = pixman_region32_not_empty(&surface_overlap);
988 pixman_region32_fini(&surface_overlap);
989 pixman_region32_union(&overlap, &overlap,
990 &es->transform.boundingbox);
993 weston_output_set_cursor(output, ec->input_device);
995 wl_list_for_each(es, &ec->surface_list, link) {
996 pixman_region32_subtract(&es->damage, &es->damage, &opaque);
997 pixman_region32_union(&new_damage, &new_damage, &es->damage);
998 pixman_region32_union(&opaque, &opaque, &es->transform.opaque);
1001 pixman_region32_init(&total_damage);
1002 pixman_region32_union(&total_damage, &new_damage,
1003 &output->previous_damage);
1004 pixman_region32_intersect(&output->previous_damage,
1005 &new_damage, &output->region);
1007 pixman_region32_fini(&opaque);
1008 pixman_region32_fini(&overlap);
1009 pixman_region32_fini(&new_damage);
1011 wl_list_for_each(es, &ec->surface_list, link) {
1012 pixman_region32_copy(&es->damage, &total_damage);
1013 pixman_region32_subtract(&total_damage,
1014 &total_damage, &es->transform.opaque);
1017 output->repaint(output);
1019 pixman_region32_fini(&total_damage);
1021 output->repaint_needed = 0;
1023 wl_list_for_each_safe(cb, cnext, &output->frame_callback_list, link) {
1024 wl_resource_post_event(&cb->resource, WL_CALLBACK_DONE, msecs);
1025 wl_resource_destroy(&cb->resource, 0);
1028 wl_list_for_each_safe(animation, next, &ec->animation_list, link)
1029 animation->frame(animation, output, msecs);
1033 idle_repaint(void *data)
1035 struct weston_output *output = data;
1037 /* An idle repaint may have been cancelled by vt switching away. */
1038 if (output->repaint_needed)
1039 weston_output_repaint(output, weston_compositor_get_time());
1041 output->repaint_scheduled = 0;
1045 weston_output_finish_frame(struct weston_output *output, int msecs)
1047 if (output->repaint_needed)
1048 weston_output_repaint(output, msecs);
1050 output->repaint_scheduled = 0;
1054 weston_compositor_schedule_repaint(struct weston_compositor *compositor)
1056 struct weston_output *output;
1057 struct wl_event_loop *loop;
1059 if (compositor->state == WESTON_COMPOSITOR_SLEEPING)
1062 loop = wl_display_get_event_loop(compositor->wl_display);
1063 wl_list_for_each(output, &compositor->output_list, link) {
1064 output->repaint_needed = 1;
1065 if (output->repaint_scheduled)
1068 wl_event_loop_add_idle(loop, idle_repaint, output);
1069 output->repaint_scheduled = 1;
1074 weston_compositor_fade(struct weston_compositor *compositor, float tint)
1076 struct weston_surface *surface;
1079 done = weston_spring_done(&compositor->fade.spring);
1080 compositor->fade.spring.target = tint;
1081 if (weston_spring_done(&compositor->fade.spring))
1085 compositor->fade.spring.timestamp =
1086 weston_compositor_get_time();
1088 if (compositor->fade.surface == NULL) {
1089 surface = weston_surface_create(compositor);
1090 weston_surface_configure(surface, 0, 0, 8192, 8192);
1091 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 0.0);
1092 wl_list_insert(&compositor->surface_list, &surface->link);
1093 weston_surface_assign_output(surface);
1094 compositor->fade.surface = surface;
1097 weston_surface_damage(compositor->fade.surface);
1098 if (wl_list_empty(&compositor->fade.animation.link))
1099 wl_list_insert(compositor->animation_list.prev,
1100 &compositor->fade.animation.link);
1104 surface_destroy(struct wl_client *client, struct wl_resource *resource)
1106 wl_resource_destroy(resource, weston_compositor_get_time());
1110 weston_surface_assign_output(struct weston_surface *es)
1112 struct weston_compositor *ec = es->compositor;
1113 struct weston_output *output, *new_output;
1114 pixman_region32_t region;
1118 weston_surface_update_transform(es);
1122 pixman_region32_init(®ion);
1123 wl_list_for_each(output, &ec->output_list, link) {
1124 pixman_region32_intersect(®ion, &es->transform.boundingbox,
1127 e = pixman_region32_extents(®ion);
1128 area = (e->x2 - e->x1) * (e->y2 - e->y1);
1131 new_output = output;
1135 pixman_region32_fini(®ion);
1137 es->output = new_output;
1138 if (!wl_list_empty(&es->frame_callback_list)) {
1139 wl_list_insert_list(new_output->frame_callback_list.prev,
1140 &es->frame_callback_list);
1141 wl_list_init(&es->frame_callback_list);
1146 surface_attach(struct wl_client *client,
1147 struct wl_resource *resource,
1148 struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
1150 struct weston_surface *es = resource->data;
1151 struct weston_shell *shell = es->compositor->shell;
1152 struct wl_buffer *buffer;
1154 weston_surface_damage_below(es);
1157 weston_buffer_post_release(es->buffer);
1158 wl_list_remove(&es->buffer_destroy_listener.link);
1161 if (!buffer_resource && es->output) {
1162 wl_list_remove(&es->link);
1163 es->visual = WESTON_NONE_VISUAL;
1168 buffer = buffer_resource->data;
1169 buffer->busy_count++;
1170 es->buffer = buffer;
1171 wl_list_insert(es->buffer->resource.destroy_listener_list.prev,
1172 &es->buffer_destroy_listener.link);
1174 if (es->visual == WESTON_NONE_VISUAL) {
1175 shell->map(shell, es, buffer->width, buffer->height);
1176 } else if (sx != 0 || sy != 0 ||
1177 es->geometry.width != buffer->width ||
1178 es->geometry.height != buffer->height) {
1179 GLfloat from_x, from_y;
1182 surface_to_global_float(es, 0, 0, &from_x, &from_y);
1183 surface_to_global_float(es, sx, sy, &to_x, &to_y);
1184 shell->configure(shell, es,
1185 es->geometry.x + to_x - from_x,
1186 es->geometry.y + to_y - from_y,
1187 buffer->width, buffer->height);
1190 weston_buffer_attach(buffer, &es->surface);
1194 surface_damage(struct wl_client *client,
1195 struct wl_resource *resource,
1196 int32_t x, int32_t y, int32_t width, int32_t height)
1198 struct weston_surface *es = resource->data;
1200 weston_surface_damage_rectangle(es, x, y, width, height);
1204 destroy_frame_callback(struct wl_resource *resource)
1206 struct weston_frame_callback *cb = resource->data;
1208 wl_list_remove(&cb->link);
1213 surface_frame(struct wl_client *client,
1214 struct wl_resource *resource, uint32_t callback)
1216 struct weston_frame_callback *cb;
1217 struct weston_surface *es = resource->data;
1219 cb = malloc(sizeof *cb);
1221 wl_resource_post_no_memory(resource);
1225 cb->resource.object.interface = &wl_callback_interface;
1226 cb->resource.object.id = callback;
1227 cb->resource.destroy = destroy_frame_callback;
1228 cb->resource.client = client;
1229 cb->resource.data = cb;
1231 wl_client_add_resource(client, &cb->resource);
1234 wl_list_insert(es->output->frame_callback_list.prev,
1237 wl_list_insert(es->frame_callback_list.prev, &cb->link);
1241 const static struct wl_surface_interface surface_interface = {
1249 compositor_create_surface(struct wl_client *client,
1250 struct wl_resource *resource, uint32_t id)
1252 struct weston_compositor *ec = resource->data;
1253 struct weston_surface *surface;
1255 surface = weston_surface_create(ec);
1256 if (surface == NULL) {
1257 wl_resource_post_no_memory(resource);
1261 surface->surface.resource.destroy = destroy_surface;
1263 surface->surface.resource.object.id = id;
1264 surface->surface.resource.object.interface = &wl_surface_interface;
1265 surface->surface.resource.object.implementation =
1266 (void (**)(void)) &surface_interface;
1267 surface->surface.resource.data = surface;
1269 wl_client_add_resource(client, &surface->surface.resource);
1272 const static struct wl_compositor_interface compositor_interface = {
1273 compositor_create_surface,
1277 weston_compositor_wake(struct weston_compositor *compositor)
1279 compositor->state = WESTON_COMPOSITOR_ACTIVE;
1280 weston_compositor_fade(compositor, 0.0);
1282 wl_event_source_timer_update(compositor->idle_source,
1283 compositor->idle_time * 1000);
1287 weston_compositor_activity(struct weston_compositor *compositor)
1289 if (compositor->state == WESTON_COMPOSITOR_ACTIVE) {
1290 weston_compositor_wake(compositor);
1292 compositor->shell->unlock(compositor->shell);
1297 weston_compositor_idle_inhibit(struct weston_compositor *compositor)
1299 weston_compositor_activity(compositor);
1300 compositor->idle_inhibit++;
1304 weston_compositor_idle_release(struct weston_compositor *compositor)
1306 compositor->idle_inhibit--;
1307 weston_compositor_activity(compositor);
1311 idle_handler(void *data)
1313 struct weston_compositor *compositor = data;
1315 if (compositor->idle_inhibit)
1318 weston_compositor_fade(compositor, 1.0);
1324 notify_motion(struct wl_input_device *device, uint32_t time, int x, int y)
1326 struct weston_output *output;
1327 const struct wl_grab_interface *interface;
1328 struct weston_input_device *wd = (struct weston_input_device *) device;
1329 struct weston_compositor *ec = wd->compositor;
1330 int x_valid = 0, y_valid = 0;
1331 int min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN;
1333 weston_compositor_activity(ec);
1335 wl_list_for_each(output, &ec->output_list, link) {
1336 if (output->x <= x && x <= output->x + output->current->width)
1339 if (output->y <= y && y <= output->y + output->current->height)
1342 /* FIXME: calculate this only on output addition/deletion */
1343 if (output->x < min_x)
1345 if (output->y < min_y)
1348 if (output->x + output->current->width > max_x)
1349 max_x = output->x + output->current->width;
1350 if (output->y + output->current->height > max_y)
1351 max_y = output->y + output->current->height;
1357 else if (x >= max_x)
1363 else if (y >= max_y)
1370 weston_device_repick(device, time);
1371 interface = device->grab->interface;
1372 interface->motion(device->grab, time,
1373 device->grab->x, device->grab->y);
1376 weston_surface_set_position(wd->sprite,
1377 device->x - wd->hotspot_x,
1378 device->y - wd->hotspot_y);
1380 weston_compositor_schedule_repaint(ec);
1385 weston_surface_activate(struct weston_surface *surface,
1386 struct weston_input_device *device, uint32_t time)
1388 weston_surface_raise(surface);
1389 wl_input_device_set_keyboard_focus(&device->input_device,
1390 &surface->surface, time);
1391 wl_data_device_set_keyboard_focus(&device->input_device);
1395 notify_button(struct wl_input_device *device,
1396 uint32_t time, int32_t button, int32_t state)
1398 struct weston_input_device *wd = (struct weston_input_device *) device;
1399 struct weston_compositor *compositor = wd->compositor;
1402 weston_compositor_idle_inhibit(compositor);
1403 if (device->button_count == 0) {
1404 device->grab_button = button;
1405 device->grab_time = time;
1406 device->grab_x = device->x;
1407 device->grab_y = device->y;
1409 device->button_count++;
1411 weston_compositor_idle_release(compositor);
1412 device->button_count--;
1415 weston_compositor_run_binding(compositor, wd, time, 0, button, state);
1417 device->grab->interface->button(device->grab, time, button, state);
1422 update_modifier_state(struct weston_input_device *device,
1423 uint32_t key, uint32_t state)
1430 modifier = MODIFIER_CTRL;
1435 modifier = MODIFIER_ALT;
1440 modifier = MODIFIER_SUPER;
1449 device->modifier_state |= modifier;
1451 device->modifier_state &= ~modifier;
1455 notify_key(struct wl_input_device *device,
1456 uint32_t time, uint32_t key, uint32_t state)
1458 struct weston_input_device *wd = (struct weston_input_device *) device;
1459 struct weston_compositor *compositor = wd->compositor;
1463 weston_compositor_idle_inhibit(compositor);
1465 weston_compositor_idle_release(compositor);
1467 weston_compositor_run_binding(compositor, wd, time, key, 0, state);
1469 update_modifier_state(wd, key, state);
1470 end = device->keys.data + device->keys.size;
1471 for (k = device->keys.data; k < end; k++) {
1475 device->keys.size = (void *) end - device->keys.data;
1477 k = wl_array_add(&device->keys, sizeof *k);
1481 if (device->keyboard_focus_resource)
1482 wl_resource_post_event(device->keyboard_focus_resource,
1483 WL_INPUT_DEVICE_KEY, time, key, state);
1487 notify_pointer_focus(struct wl_input_device *device,
1488 uint32_t time, struct weston_output *output,
1489 int32_t x, int32_t y)
1491 struct weston_input_device *wd = (struct weston_input_device *) device;
1492 struct weston_compositor *compositor = wd->compositor;
1497 compositor->focus = 1;
1498 weston_compositor_repick(compositor);
1500 compositor->focus = 0;
1501 weston_compositor_repick(compositor);
1506 notify_keyboard_focus(struct wl_input_device *device,
1507 uint32_t time, struct weston_output *output,
1508 struct wl_array *keys)
1510 struct weston_input_device *wd =
1511 (struct weston_input_device *) device;
1512 struct weston_compositor *compositor = wd->compositor;
1513 struct weston_surface *es;
1516 if (!wl_list_empty(&compositor->surface_list))
1517 es = container_of(compositor->surface_list.next,
1518 struct weston_surface, link);
1523 wl_array_copy(&wd->input_device.keys, keys);
1524 wd->modifier_state = 0;
1525 end = device->keys.data + device->keys.size;
1526 for (k = device->keys.data; k < end; k++) {
1527 weston_compositor_idle_inhibit(compositor);
1528 update_modifier_state(wd, *k, 1);
1531 if (es && es->surface.resource.client)
1532 wl_input_device_set_keyboard_focus(&wd->input_device,
1533 &es->surface, time);
1535 end = device->keys.data + device->keys.size;
1536 for (k = device->keys.data; k < end; k++)
1537 weston_compositor_idle_release(compositor);
1539 wd->modifier_state = 0;
1540 wl_input_device_set_keyboard_focus(&wd->input_device,
1545 /* TODO: share this function with wayland-server.c */
1546 static struct wl_resource *
1547 find_resource_for_surface(struct wl_list *list, struct wl_surface *surface)
1549 struct wl_resource *r;
1554 wl_list_for_each(r, list, link) {
1555 if (r->client == surface->resource.client)
1563 lose_touch_focus_resource(struct wl_listener *listener,
1564 struct wl_resource *resource, uint32_t time)
1566 struct weston_input_device *device =
1567 container_of(listener, struct weston_input_device,
1568 touch_focus_resource_listener);
1570 device->touch_focus_resource = NULL;
1574 lose_touch_focus(struct wl_listener *listener,
1575 struct wl_resource *resource, uint32_t time)
1577 struct weston_input_device *device =
1578 container_of(listener, struct weston_input_device,
1579 touch_focus_listener);
1581 device->touch_focus = NULL;
1585 touch_set_focus(struct weston_input_device *device,
1586 struct wl_surface *surface, uint32_t time)
1588 struct wl_input_device *input_device = &device->input_device;
1589 struct wl_resource *resource;
1591 if (device->touch_focus == surface)
1596 find_resource_for_surface(&input_device->resource_list,
1599 fprintf(stderr, "couldn't find resource\n");
1603 device->touch_focus_resource_listener.func =
1604 lose_touch_focus_resource;
1605 wl_list_insert(resource->destroy_listener_list.prev,
1606 &device->touch_focus_resource_listener.link);
1607 device->touch_focus_listener.func = lose_touch_focus;
1608 wl_list_insert(surface->resource.destroy_listener_list.prev,
1609 &device->touch_focus_listener.link);
1611 device->touch_focus = surface;
1612 device->touch_focus_resource = resource;
1614 if (device->touch_focus)
1615 wl_list_remove(&device->touch_focus_listener.link);
1616 if (device->touch_focus_resource)
1617 wl_list_remove(&device->touch_focus_resource_listener.link);
1618 device->touch_focus = NULL;
1619 device->touch_focus_resource = NULL;
1624 * notify_touch - emulates button touches and notifies surfaces accordingly.
1626 * It assumes always the correct cycle sequence until it gets here: touch_down
1627 * → touch_update → ... → touch_update → touch_end. The driver is responsible
1628 * for sending along such order.
1632 notify_touch(struct wl_input_device *device, uint32_t time, int touch_id,
1633 int x, int y, int touch_type)
1635 struct weston_input_device *wd = (struct weston_input_device *) device;
1636 struct weston_compositor *ec = wd->compositor;
1637 struct weston_surface *es;
1640 switch (touch_type) {
1641 case WL_INPUT_DEVICE_TOUCH_DOWN:
1642 weston_compositor_idle_inhibit(ec);
1646 /* the first finger down picks the surface, and all further go
1647 * to that surface for the remainder of the touch session i.e.
1648 * until all touch points are up again. */
1649 if (wd->num_tp == 1) {
1650 es = weston_compositor_pick_surface(ec, x, y, &sx, &sy);
1651 touch_set_focus(wd, &es->surface, time);
1652 } else if (wd->touch_focus) {
1653 es = (struct weston_surface *) wd->touch_focus;
1654 weston_surface_from_global(es, x, y, &sx, &sy);
1657 if (wd->touch_focus_resource && wd->touch_focus)
1658 wl_resource_post_event(wd->touch_focus_resource,
1663 case WL_INPUT_DEVICE_TOUCH_MOTION:
1664 es = (struct weston_surface *) wd->touch_focus;
1668 weston_surface_from_global(es, x, y, &sx, &sy);
1669 if (wd->touch_focus_resource)
1670 wl_resource_post_event(wd->touch_focus_resource,
1674 case WL_INPUT_DEVICE_TOUCH_UP:
1675 weston_compositor_idle_release(ec);
1678 if (wd->touch_focus_resource)
1679 wl_resource_post_event(wd->touch_focus_resource,
1680 touch_type, time, touch_id);
1681 if (wd->num_tp == 0)
1682 touch_set_focus(wd, NULL, time);
1688 input_device_attach(struct wl_client *client,
1689 struct wl_resource *resource,
1691 struct wl_resource *buffer_resource, int32_t x, int32_t y)
1693 struct weston_input_device *device = resource->data;
1694 struct weston_compositor *compositor = device->compositor;
1695 struct wl_buffer *buffer;
1697 if (time < device->input_device.pointer_focus_time)
1699 if (device->input_device.pointer_focus == NULL)
1701 if (device->input_device.pointer_focus->resource.client != client)
1705 weston_surface_damage_below(device->sprite);
1707 if (!buffer_resource && device->sprite->output) {
1708 wl_list_remove(&device->sprite->link);
1709 device->sprite->visual = WESTON_NONE_VISUAL;
1710 device->sprite->output = NULL;
1714 if (!device->sprite->output) {
1715 wl_list_insert(&compositor->surface_list,
1716 &device->sprite->link);
1717 weston_surface_assign_output(device->sprite);
1720 buffer = buffer_resource->data;
1721 device->hotspot_x = x;
1722 device->hotspot_y = y;
1723 weston_surface_configure(device->sprite,
1724 device->input_device.x - device->hotspot_x,
1725 device->input_device.y - device->hotspot_y,
1726 buffer->width, buffer->height);
1728 weston_buffer_attach(buffer, &device->sprite->surface);
1731 const static struct wl_input_device_interface input_device_interface = {
1732 input_device_attach,
1735 static void unbind_input_device(struct wl_resource *resource)
1737 wl_list_remove(&resource->link);
1742 bind_input_device(struct wl_client *client,
1743 void *data, uint32_t version, uint32_t id)
1745 struct wl_input_device *device = data;
1746 struct wl_resource *resource;
1748 resource = wl_client_add_object(client, &wl_input_device_interface,
1749 &input_device_interface, id, data);
1750 wl_list_insert(&device->resource_list, &resource->link);
1751 resource->destroy = unbind_input_device;
1755 weston_input_device_init(struct weston_input_device *device,
1756 struct weston_compositor *ec)
1758 wl_input_device_init(&device->input_device);
1760 wl_display_add_global(ec->wl_display, &wl_input_device_interface,
1761 device, bind_input_device);
1763 device->sprite = weston_surface_create(ec);
1765 device->compositor = ec;
1766 device->hotspot_x = 16;
1767 device->hotspot_y = 16;
1768 device->modifier_state = 0;
1771 wl_list_insert(ec->input_device_list.prev, &device->link);
1775 weston_input_device_release(struct weston_input_device *device)
1777 wl_list_remove(&device->link);
1778 /* The global object is destroyed at wl_display_destroy() time. */
1781 destroy_surface(&device->sprite->surface.resource);
1783 wl_input_device_release(&device->input_device);
1787 bind_output(struct wl_client *client,
1788 void *data, uint32_t version, uint32_t id)
1790 struct weston_output *output = data;
1791 struct weston_mode *mode;
1792 struct wl_resource *resource;
1794 resource = wl_client_add_object(client,
1795 &wl_output_interface, NULL, id, data);
1797 wl_resource_post_event(resource,
1804 output->make, output->model);
1806 wl_list_for_each (mode, &output->mode_list, link) {
1807 wl_resource_post_event(resource,
1816 static const char vertex_shader[] =
1817 "uniform mat4 proj;\n"
1818 "attribute vec2 position;\n"
1819 "attribute vec2 texcoord;\n"
1820 "varying vec2 v_texcoord;\n"
1823 " gl_Position = proj * vec4(position, 0.0, 1.0);\n"
1824 " v_texcoord = texcoord;\n"
1827 static const char texture_fragment_shader[] =
1828 "precision mediump float;\n"
1829 "varying vec2 v_texcoord;\n"
1830 "uniform sampler2D tex;\n"
1831 "uniform float alpha;\n"
1832 "uniform float texwidth;\n"
1835 " if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n"
1836 " v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n"
1838 " gl_FragColor = texture2D(tex, v_texcoord)\n;"
1839 " gl_FragColor = alpha * gl_FragColor;\n"
1842 static const char solid_fragment_shader[] =
1843 "precision mediump float;\n"
1844 "uniform vec4 color;\n"
1847 " gl_FragColor = color\n;"
1851 compile_shader(GLenum type, const char *source)
1857 s = glCreateShader(type);
1858 glShaderSource(s, 1, &source, NULL);
1860 glGetShaderiv(s, GL_COMPILE_STATUS, &status);
1862 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
1863 fprintf(stderr, "shader info: %s\n", msg);
1871 weston_shader_init(struct weston_shader *shader,
1872 const char *vertex_source, const char *fragment_source)
1877 shader->vertex_shader =
1878 compile_shader(GL_VERTEX_SHADER, vertex_source);
1879 shader->fragment_shader =
1880 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
1882 shader->program = glCreateProgram();
1883 glAttachShader(shader->program, shader->vertex_shader);
1884 glAttachShader(shader->program, shader->fragment_shader);
1885 glBindAttribLocation(shader->program, 0, "position");
1886 glBindAttribLocation(shader->program, 1, "texcoord");
1888 glLinkProgram(shader->program);
1889 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
1891 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
1892 fprintf(stderr, "link info: %s\n", msg);
1896 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
1897 shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
1898 shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
1899 shader->color_uniform = glGetUniformLocation(shader->program, "color");
1900 shader->texwidth_uniform = glGetUniformLocation(shader->program,
1907 weston_output_destroy(struct weston_output *output)
1909 pixman_region32_fini(&output->region);
1910 pixman_region32_fini(&output->previous_damage);
1914 weston_output_move(struct weston_output *output, int x, int y)
1921 pixman_region32_init(&output->previous_damage);
1922 pixman_region32_init_rect(&output->region, x, y,
1923 output->current->width,
1924 output->current->height);
1926 weston_matrix_init(&output->matrix);
1927 weston_matrix_translate(&output->matrix,
1928 -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0),
1929 -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0);
1931 flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
1932 weston_matrix_scale(&output->matrix,
1933 2.0 / (output->current->width + output->border.left + output->border.right),
1934 flip * 2.0 / (output->current->height + output->border.top + output->border.bottom), 1);
1936 weston_output_damage(output);
1940 weston_output_init(struct weston_output *output, struct weston_compositor *c,
1941 int x, int y, int width, int height, uint32_t flags)
1943 output->compositor = c;
1946 output->border.top = 0;
1947 output->border.bottom = 0;
1948 output->border.left = 0;
1949 output->border.right = 0;
1950 output->mm_width = width;
1951 output->mm_height = height;
1953 output->flags = flags;
1954 weston_output_move(output, x, y);
1956 wl_list_init(&output->frame_callback_list);
1958 wl_display_add_global(c->wl_display,
1959 &wl_output_interface, output, bind_output);
1963 shm_buffer_created(struct wl_buffer *buffer)
1965 struct wl_list *surfaces_attached_to;
1967 surfaces_attached_to = malloc(sizeof *surfaces_attached_to);
1968 if (!surfaces_attached_to) {
1969 buffer->user_data = NULL;
1973 wl_list_init(surfaces_attached_to);
1975 buffer->user_data = surfaces_attached_to;
1979 shm_buffer_damaged(struct wl_buffer *buffer,
1980 int32_t x, int32_t y, int32_t width, int32_t height)
1982 struct wl_list *surfaces_attached_to = buffer->user_data;
1983 struct weston_surface *es;
1984 GLsizei tex_width = wl_shm_buffer_get_stride(buffer) / 4;
1986 wl_list_for_each(es, surfaces_attached_to, buffer_link) {
1987 glBindTexture(GL_TEXTURE_2D, es->texture);
1988 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
1989 tex_width, buffer->height, 0,
1990 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1991 wl_shm_buffer_get_data(buffer));
1992 /* Hmm, should use glTexSubImage2D() here but GLES2 doesn't
1993 * support any unpack attributes except GL_UNPACK_ALIGNMENT. */
1998 shm_buffer_destroyed(struct wl_buffer *buffer)
2000 struct wl_list *surfaces_attached_to = buffer->user_data;
2001 struct weston_surface *es, *next;
2003 wl_list_for_each_safe(es, next, surfaces_attached_to, buffer_link) {
2004 wl_list_remove(&es->buffer_link);
2005 wl_list_init(&es->buffer_link);
2008 free(surfaces_attached_to);
2011 const static struct wl_shm_callbacks shm_callbacks = {
2014 shm_buffer_destroyed
2018 compositor_bind(struct wl_client *client,
2019 void *data, uint32_t version, uint32_t id)
2021 struct weston_compositor *compositor = data;
2023 wl_client_add_object(client, &wl_compositor_interface,
2024 &compositor_interface, id, compositor);
2028 weston_compositor_init(struct weston_compositor *ec, struct wl_display *display)
2030 struct wl_event_loop *loop;
2031 const char *extensions;
2033 ec->wl_display = display;
2035 if (!wl_display_add_global(display, &wl_compositor_interface,
2036 ec, compositor_bind))
2039 ec->shm = wl_shm_init(display, &shm_callbacks);
2041 ec->image_target_texture_2d =
2042 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
2043 ec->image_target_renderbuffer_storage = (void *)
2044 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
2045 ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
2046 ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
2048 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
2049 ec->unbind_display =
2050 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
2052 extensions = (const char *) glGetString(GL_EXTENSIONS);
2053 if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
2055 "GL_EXT_texture_format_BGRA8888 not available\n");
2060 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
2061 if (strstr(extensions, "EGL_WL_bind_wayland_display"))
2062 ec->has_bind_display = 1;
2063 if (ec->has_bind_display)
2064 ec->bind_display(ec->display, ec->wl_display);
2066 wl_list_init(&ec->surface_list);
2067 wl_list_init(&ec->input_device_list);
2068 wl_list_init(&ec->output_list);
2069 wl_list_init(&ec->binding_list);
2070 wl_list_init(&ec->animation_list);
2071 weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
2072 ec->fade.animation.frame = fade_frame;
2073 wl_list_init(&ec->fade.animation.link);
2075 ec->screenshooter = screenshooter_create(ec);
2077 wl_data_device_manager_init(ec->wl_display);
2079 glActiveTexture(GL_TEXTURE0);
2081 if (weston_shader_init(&ec->texture_shader,
2082 vertex_shader, texture_fragment_shader) < 0)
2084 if (weston_shader_init(&ec->solid_shader,
2085 vertex_shader, solid_fragment_shader) < 0)
2088 loop = wl_display_get_event_loop(ec->wl_display);
2089 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
2090 wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
2092 weston_compositor_schedule_repaint(ec);
2098 weston_compositor_shutdown(struct weston_compositor *ec)
2100 struct weston_output *output, *next;
2102 wl_event_source_remove(ec->idle_source);
2104 if (ec->screenshooter)
2105 screenshooter_destroy(ec->screenshooter);
2107 /* Destroy all outputs associated with this compositor */
2108 wl_list_for_each_safe(output, next, &ec->output_list, link)
2109 output->destroy(output);
2111 weston_binding_list_destroy_all(&ec->binding_list);
2113 wl_shm_finish(ec->shm);
2115 wl_array_release(&ec->vertices);
2116 wl_array_release(&ec->indices);
2119 static int on_term_signal(int signal_number, void *data)
2121 struct wl_display *display = data;
2123 fprintf(stderr, "caught signal %d\n", signal_number);
2124 wl_display_terminate(display);
2130 on_segv_signal(int s, siginfo_t *siginfo, void *context)
2136 fprintf(stderr, "caught segv\n");
2138 count = backtrace(buffer, ARRAY_LENGTH(buffer));
2139 for (i = 0; i < count; i++) {
2140 dladdr(buffer[i], &info);
2141 fprintf(stderr, " [%016lx] %s (%s)\n",
2143 info.dli_sname ? info.dli_sname : "--",
2147 longjmp(segv_jmp_buf, 1);
2152 load_module(const char *name, const char *entrypoint, void **handle)
2154 char path[PATH_MAX];
2155 void *module, *init;
2158 snprintf(path, sizeof path, MODULEDIR "/%s", name);
2160 snprintf(path, sizeof path, "%s", name);
2162 module = dlopen(path, RTLD_LAZY);
2165 "failed to load module: %s\n", dlerror());
2169 init = dlsym(module, entrypoint);
2172 "failed to lookup init function: %s\n", dlerror());
2179 int main(int argc, char *argv[])
2181 struct wl_display *display;
2182 struct weston_compositor *ec;
2183 struct wl_event_source *signals[4];
2184 struct wl_event_loop *loop;
2185 struct sigaction segv_action;
2187 void *shell_module, *backend_module;
2188 int (*shell_init)(struct weston_compositor *ec);
2189 struct weston_compositor
2190 *(*backend_init)(struct wl_display *display, char *options);
2191 char *backend = NULL;
2192 char *backend_options = "";
2195 int option_idle_time = 300;
2198 static const char opts[] = "B:b:o:S:i:s:x";
2199 static const struct option longopts[ ] = {
2200 { "backend", 1, NULL, 'B' },
2201 { "backend-options", 1, NULL, 'o' },
2202 { "socket", 1, NULL, 'S' },
2203 { "idle-time", 1, NULL, 'i' },
2204 { "shell", 1, NULL, 's' },
2205 { "xserver", 0, NULL, 'x' },
2209 while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) {
2215 backend_options = optarg;
2218 option_socket_name = optarg;
2221 option_idle_time = strtol(optarg, &p, 0);
2224 "invalid idle time option: %s\n",
2238 display = wl_display_create();
2240 loop = wl_display_get_event_loop(display);
2241 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
2243 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
2245 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
2248 wl_list_init(&child_process_list);
2249 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
2252 segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND;
2253 segv_action.sa_sigaction = on_segv_signal;
2254 sigemptyset(&segv_action.sa_mask);
2255 sigaction(SIGSEGV, &segv_action, NULL);
2258 if (getenv("WAYLAND_DISPLAY"))
2259 backend = "wayland-backend.so";
2260 else if (getenv("DISPLAY"))
2261 backend = "x11-backend.so";
2262 else if (getenv("OPENWFD"))
2263 backend = "openwfd-backend.so";
2265 backend = "drm-backend.so";
2269 shell = "desktop-shell.so";
2271 backend_init = load_module(backend, "backend_init", &backend_module);
2275 shell_init = load_module(shell, "shell_init", &shell_module);
2279 ec = backend_init(display, backend_options);
2281 fprintf(stderr, "failed to create compositor\n");
2285 ec->option_idle_time = option_idle_time;
2286 ec->idle_time = option_idle_time;
2289 weston_xserver_init(ec);
2291 if (shell_init(ec) < 0)
2294 if (wl_display_add_socket(display, option_socket_name)) {
2295 fprintf(stderr, "failed to add socket: %m\n");
2299 weston_compositor_wake(ec);
2300 if (setjmp(segv_jmp_buf) == 0)
2301 wl_display_run(display);
2303 /* prevent further rendering while shutting down */
2304 ec->state = WESTON_COMPOSITOR_SLEEPING;
2307 weston_xserver_destroy(ec);
2309 ec->shell->destroy(ec->shell);
2311 if (ec->has_bind_display)
2312 ec->unbind_display(ec->display, display);
2314 for (i = ARRAY_LENGTH(signals); i;)
2315 wl_event_source_remove(signals[--i]);
2318 wl_display_destroy(display);