Kristian Høgsberg | ffd710e | 2008-12-02 15:15:01 -0500 | [diff] [blame] | 1 | /* |
Kristian Høgsberg | 96aa7da | 2011-09-15 15:43:14 -0400 | [diff] [blame] | 2 | * Copyright © 2010-2011 Intel Corporation |
| 3 | * Copyright © 2008-2011 Kristian Høgsberg |
Pekka Paalanen | d581a8f | 2012-01-27 16:25:16 +0200 | [diff] [blame] | 4 | * Copyright © 2012 Collabora, Ltd. |
Kristian Høgsberg | ffd710e | 2008-12-02 15:15:01 -0500 | [diff] [blame] | 5 | * |
Kristian Høgsberg | 96aa7da | 2011-09-15 15:43:14 -0400 | [diff] [blame] | 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. |
Kristian Høgsberg | ffd710e | 2008-12-02 15:15:01 -0500 | [diff] [blame] | 15 | * |
Kristian Høgsberg | 96aa7da | 2011-09-15 15:43:14 -0400 | [diff] [blame] | 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. |
Kristian Høgsberg | ffd710e | 2008-12-02 15:15:01 -0500 | [diff] [blame] | 23 | */ |
| 24 | |
Kristian Høgsberg | 06bc264 | 2010-12-01 09:50:16 -0500 | [diff] [blame] | 25 | #define _GNU_SOURCE |
| 26 | |
Kristian Høgsberg | a941022 | 2011-01-14 17:22:35 -0500 | [diff] [blame] | 27 | #include "config.h" |
| 28 | |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 29 | #include <fcntl.h> |
Kristian Høgsberg | 16eb675 | 2008-10-08 22:51:32 -0400 | [diff] [blame] | 30 | #include <stdio.h> |
| 31 | #include <string.h> |
| 32 | #include <stdlib.h> |
| 33 | #include <stdint.h> |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 34 | #include <limits.h> |
Kristian Høgsberg | 8d7ca6b | 2008-11-09 00:22:51 -0500 | [diff] [blame] | 35 | #include <stdarg.h> |
Benjamin Franzke | 6f5fc69 | 2011-06-21 19:34:19 +0200 | [diff] [blame] | 36 | #include <assert.h> |
Kristian Høgsberg | 16eb675 | 2008-10-08 22:51:32 -0400 | [diff] [blame] | 37 | #include <sys/ioctl.h> |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 38 | #include <sys/mman.h> |
Kristian Høgsberg | 27da538 | 2011-06-21 17:32:25 -0400 | [diff] [blame] | 39 | #include <sys/wait.h> |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 40 | #include <sys/socket.h> |
Martin Minarik | f12c287 | 2012-06-11 00:57:39 +0200 | [diff] [blame] | 41 | #include <sys/utsname.h> |
Martin Minarik | 37032f8 | 2012-06-18 20:15:18 +0200 | [diff] [blame] | 42 | #include <sys/stat.h> |
Kristian Høgsberg | 16eb675 | 2008-10-08 22:51:32 -0400 | [diff] [blame] | 43 | #include <unistd.h> |
Kristian Høgsberg | 5487982 | 2008-11-23 17:07:32 -0500 | [diff] [blame] | 44 | #include <math.h> |
Kristian Høgsberg | fc783d4 | 2010-06-11 12:56:24 -0400 | [diff] [blame] | 45 | #include <linux/input.h> |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 46 | #include <dlfcn.h> |
Kristian Høgsberg | 8544903 | 2011-05-02 12:11:07 -0400 | [diff] [blame] | 47 | #include <signal.h> |
Kristian Høgsberg | 0690da6 | 2012-01-16 11:53:54 -0500 | [diff] [blame] | 48 | #include <setjmp.h> |
Kristian Høgsberg | a411c8b | 2012-06-08 16:16:52 -0400 | [diff] [blame] | 49 | #include <sys/time.h> |
| 50 | #include <time.h> |
Kristian Høgsberg | fc9c5e0 | 2012-06-08 16:45:33 -0400 | [diff] [blame] | 51 | #include <ctype.h> |
Kristian Høgsberg | 890bc05 | 2008-12-30 14:31:33 -0500 | [diff] [blame] | 52 | |
Pekka Paalanen | 50719bc | 2011-11-22 14:18:50 +0200 | [diff] [blame] | 53 | #include <wayland-server.h> |
Kristian Høgsberg | 8286302 | 2010-06-04 21:52:02 -0400 | [diff] [blame] | 54 | #include "compositor.h" |
Pekka Paalanen | 51aaf64 | 2012-05-30 15:53:41 +0300 | [diff] [blame] | 55 | #include "../shared/os-compatibility.h" |
Kristian Høgsberg | a411c8b | 2012-06-08 16:16:52 -0400 | [diff] [blame] | 56 | #include "git-version.h" |
Kristian Høgsberg | 5ee1a60 | 2008-12-11 23:18:45 -0500 | [diff] [blame] | 57 | |
Kristian Høgsberg | 27da538 | 2011-06-21 17:32:25 -0400 | [diff] [blame] | 58 | static struct wl_list child_process_list; |
Kristian Høgsberg | 7b884bc | 2012-07-31 14:32:01 -0400 | [diff] [blame] | 59 | static struct weston_compositor *segv_compositor; |
Kristian Høgsberg | 27da538 | 2011-06-21 17:32:25 -0400 | [diff] [blame] | 60 | |
| 61 | static int |
| 62 | sigchld_handler(int signal_number, void *data) |
| 63 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 64 | struct weston_process *p; |
Kristian Høgsberg | 27da538 | 2011-06-21 17:32:25 -0400 | [diff] [blame] | 65 | int status; |
| 66 | pid_t pid; |
| 67 | |
Bill Spitzak | 027b962 | 2012-03-17 15:22:03 -0700 | [diff] [blame] | 68 | pid = waitpid(-1, &status, WNOHANG); |
| 69 | if (!pid) |
| 70 | return 1; |
| 71 | |
Kristian Høgsberg | 27da538 | 2011-06-21 17:32:25 -0400 | [diff] [blame] | 72 | wl_list_for_each(p, &child_process_list, link) { |
| 73 | if (p->pid == pid) |
| 74 | break; |
| 75 | } |
| 76 | |
| 77 | if (&p->link == &child_process_list) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 78 | weston_log("unknown child process exited\n"); |
Kristian Høgsberg | 27da538 | 2011-06-21 17:32:25 -0400 | [diff] [blame] | 79 | return 1; |
| 80 | } |
| 81 | |
| 82 | wl_list_remove(&p->link); |
| 83 | p->cleanup(p, status); |
| 84 | |
| 85 | return 1; |
| 86 | } |
| 87 | |
Alex Wu | 2dda604 | 2012-04-17 17:20:47 +0800 | [diff] [blame] | 88 | WL_EXPORT int |
| 89 | weston_output_switch_mode(struct weston_output *output, struct weston_mode *mode) |
| 90 | { |
| 91 | if (!output->switch_mode) |
| 92 | return -1; |
| 93 | |
| 94 | return output->switch_mode(output, mode); |
| 95 | } |
| 96 | |
Kristian Høgsberg | 27da538 | 2011-06-21 17:32:25 -0400 | [diff] [blame] | 97 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 98 | weston_watch_process(struct weston_process *process) |
Kristian Høgsberg | 27da538 | 2011-06-21 17:32:25 -0400 | [diff] [blame] | 99 | { |
| 100 | wl_list_insert(&child_process_list, &process->link); |
| 101 | } |
| 102 | |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 103 | static void |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 104 | child_client_exec(int sockfd, const char *path) |
| 105 | { |
Kristian Høgsberg | d42b0c9 | 2011-12-08 10:19:40 -0500 | [diff] [blame] | 106 | int clientfd; |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 107 | char s[32]; |
Pekka Paalanen | c47ddfd | 2011-12-08 10:44:56 +0200 | [diff] [blame] | 108 | sigset_t allsigs; |
| 109 | |
| 110 | /* do not give our signal mask to the new process */ |
| 111 | sigfillset(&allsigs); |
| 112 | sigprocmask(SIG_UNBLOCK, &allsigs, NULL); |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 113 | |
Kristian Høgsberg | eb76484 | 2012-01-31 22:17:25 -0500 | [diff] [blame] | 114 | /* Launch clients as the user. */ |
| 115 | seteuid(getuid()); |
| 116 | |
Kristian Høgsberg | d42b0c9 | 2011-12-08 10:19:40 -0500 | [diff] [blame] | 117 | /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a |
| 118 | * non-CLOEXEC fd to pass through exec. */ |
| 119 | clientfd = dup(sockfd); |
| 120 | if (clientfd == -1) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 121 | weston_log("compositor: dup failed: %m\n"); |
Kristian Høgsberg | d42b0c9 | 2011-12-08 10:19:40 -0500 | [diff] [blame] | 122 | return; |
| 123 | } |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 124 | |
Kristian Høgsberg | d42b0c9 | 2011-12-08 10:19:40 -0500 | [diff] [blame] | 125 | snprintf(s, sizeof s, "%d", clientfd); |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 126 | setenv("WAYLAND_SOCKET", s, 1); |
| 127 | |
| 128 | if (execl(path, path, NULL) < 0) |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 129 | weston_log("compositor: executing '%s' failed: %m\n", |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 130 | path); |
| 131 | } |
| 132 | |
| 133 | WL_EXPORT struct wl_client * |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 134 | weston_client_launch(struct weston_compositor *compositor, |
| 135 | struct weston_process *proc, |
| 136 | const char *path, |
| 137 | weston_process_cleanup_func_t cleanup) |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 138 | { |
| 139 | int sv[2]; |
| 140 | pid_t pid; |
| 141 | struct wl_client *client; |
| 142 | |
Pekka Paalanen | 51aaf64 | 2012-05-30 15:53:41 +0300 | [diff] [blame] | 143 | if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 144 | weston_log("weston_client_launch: " |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 145 | "socketpair failed while launching '%s': %m\n", |
| 146 | path); |
| 147 | return NULL; |
| 148 | } |
| 149 | |
| 150 | pid = fork(); |
| 151 | if (pid == -1) { |
| 152 | close(sv[0]); |
| 153 | close(sv[1]); |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 154 | weston_log("weston_client_launch: " |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 155 | "fork failed while launching '%s': %m\n", path); |
| 156 | return NULL; |
| 157 | } |
| 158 | |
| 159 | if (pid == 0) { |
| 160 | child_client_exec(sv[1], path); |
| 161 | exit(-1); |
| 162 | } |
| 163 | |
| 164 | close(sv[1]); |
| 165 | |
| 166 | client = wl_client_create(compositor->wl_display, sv[0]); |
| 167 | if (!client) { |
| 168 | close(sv[0]); |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 169 | weston_log("weston_client_launch: " |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 170 | "wl_client_create failed while launching '%s'.\n", |
| 171 | path); |
| 172 | return NULL; |
| 173 | } |
| 174 | |
| 175 | proc->pid = pid; |
| 176 | proc->cleanup = cleanup; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 177 | weston_watch_process(proc); |
Pekka Paalanen | 409ef0a | 2011-12-02 15:30:21 +0200 | [diff] [blame] | 178 | |
| 179 | return client; |
| 180 | } |
| 181 | |
| 182 | static void |
Kristian Høgsberg | a85b4fb | 2012-06-20 09:24:35 -0400 | [diff] [blame] | 183 | update_shm_texture(struct weston_surface *surface); |
| 184 | |
| 185 | static void |
Kristian Høgsberg | 27e3052 | 2012-04-11 23:18:23 -0400 | [diff] [blame] | 186 | surface_handle_buffer_destroy(struct wl_listener *listener, void *data) |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 187 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 188 | struct weston_surface *es = |
| 189 | container_of(listener, struct weston_surface, |
| 190 | buffer_destroy_listener); |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 191 | |
Kristian Høgsberg | a85b4fb | 2012-06-20 09:24:35 -0400 | [diff] [blame] | 192 | if (es->buffer && wl_buffer_is_shm(es->buffer)) |
| 193 | update_shm_texture(es); |
| 194 | |
Kristian Høgsberg | 2459694 | 2011-10-24 17:51:02 -0400 | [diff] [blame] | 195 | es->buffer = NULL; |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 196 | } |
| 197 | |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 198 | static const pixman_region32_data_t undef_region_data; |
| 199 | |
| 200 | static void |
| 201 | undef_region(pixman_region32_t *region) |
| 202 | { |
Kristian Høgsberg | 66a099b | 2012-05-29 16:49:45 -0400 | [diff] [blame] | 203 | if (region->data != &undef_region_data) |
| 204 | pixman_region32_fini(region); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 205 | region->data = (pixman_region32_data_t *) &undef_region_data; |
| 206 | } |
| 207 | |
| 208 | static int |
| 209 | region_is_undefined(pixman_region32_t *region) |
| 210 | { |
| 211 | return region->data == &undef_region_data; |
| 212 | } |
| 213 | |
Ander Conselvan de Oliveira | 90fbbd7 | 2012-02-28 17:59:33 +0200 | [diff] [blame] | 214 | static void |
| 215 | empty_region(pixman_region32_t *region) |
| 216 | { |
| 217 | if (!region_is_undefined(region)) |
| 218 | pixman_region32_fini(region); |
| 219 | |
| 220 | pixman_region32_init(region); |
| 221 | } |
| 222 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 223 | WL_EXPORT struct weston_surface * |
Kristian Høgsberg | 18c9300 | 2012-01-27 11:58:31 -0500 | [diff] [blame] | 224 | weston_surface_create(struct weston_compositor *compositor) |
Kristian Høgsberg | 1a208d5 | 2009-02-10 14:20:26 -0500 | [diff] [blame] | 225 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 226 | struct weston_surface *surface; |
Kristian Høgsberg | 77fb167 | 2010-08-16 10:38:29 -0400 | [diff] [blame] | 227 | |
Pekka Paalanen | 56cdea9 | 2011-11-23 16:14:12 +0200 | [diff] [blame] | 228 | surface = calloc(1, sizeof *surface); |
Kristian Høgsberg | 77fb167 | 2010-08-16 10:38:29 -0400 | [diff] [blame] | 229 | if (surface == NULL) |
| 230 | return NULL; |
| 231 | |
Kristian Høgsberg | 27e3052 | 2012-04-11 23:18:23 -0400 | [diff] [blame] | 232 | wl_signal_init(&surface->surface.resource.destroy_signal); |
Kristian Høgsberg | 4889154 | 2012-02-23 17:38:33 -0500 | [diff] [blame] | 233 | |
Kristian Høgsberg | f6b1471 | 2011-01-06 15:32:14 -0500 | [diff] [blame] | 234 | wl_list_init(&surface->link); |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 235 | wl_list_init(&surface->layer_link); |
Kristian Høgsberg | c551bd2 | 2010-12-06 16:43:16 -0500 | [diff] [blame] | 236 | |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 237 | surface->surface.resource.client = NULL; |
Kristian Høgsberg | 8244b44 | 2011-06-23 15:44:14 -0400 | [diff] [blame] | 238 | |
Kristian Høgsberg | 1a208d5 | 2009-02-10 14:20:26 -0500 | [diff] [blame] | 239 | surface->compositor = compositor; |
Kristian Høgsberg | a416fa1 | 2012-05-21 14:06:52 -0400 | [diff] [blame] | 240 | surface->alpha = 1.0; |
Kristian Høgsberg | d6ad122 | 2012-05-17 11:11:15 -0400 | [diff] [blame] | 241 | surface->blend = 1; |
Kristian Høgsberg | 0b0c2bb | 2012-05-15 23:16:53 -0400 | [diff] [blame] | 242 | surface->opaque_rect[0] = 0.0; |
| 243 | surface->opaque_rect[1] = 0.0; |
| 244 | surface->opaque_rect[2] = 0.0; |
| 245 | surface->opaque_rect[3] = 0.0; |
Juan Zhao | 4643661 | 2012-03-20 01:48:46 +0800 | [diff] [blame] | 246 | surface->pitch = 1; |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 247 | |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 248 | surface->num_textures = 0; |
| 249 | surface->num_images = 0; |
| 250 | |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 251 | surface->buffer = NULL; |
Kristian Høgsberg | 6f7179c | 2011-08-29 16:09:32 -0400 | [diff] [blame] | 252 | surface->output = NULL; |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 253 | |
Kristian Høgsberg | 20300ba | 2011-06-23 20:29:12 -0400 | [diff] [blame] | 254 | pixman_region32_init(&surface->damage); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 255 | pixman_region32_init(&surface->opaque); |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 256 | pixman_region32_init(&surface->clip); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 257 | undef_region(&surface->input); |
Pekka Paalanen | 730d87e | 2012-02-09 16:39:38 +0200 | [diff] [blame] | 258 | pixman_region32_init(&surface->transform.opaque); |
Kristian Høgsberg | 496433b | 2011-11-15 13:50:21 -0500 | [diff] [blame] | 259 | wl_list_init(&surface->frame_callback_list); |
Kristian Høgsberg | 20300ba | 2011-06-23 20:29:12 -0400 | [diff] [blame] | 260 | |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 261 | surface->buffer_destroy_listener.notify = |
| 262 | surface_handle_buffer_destroy; |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 263 | |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 264 | wl_list_init(&surface->geometry.transformation_list); |
Pekka Paalanen | cd40362 | 2012-01-25 13:37:39 +0200 | [diff] [blame] | 265 | wl_list_insert(&surface->geometry.transformation_list, |
| 266 | &surface->transform.position.link); |
| 267 | weston_matrix_init(&surface->transform.position.matrix); |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 268 | pixman_region32_init(&surface->transform.boundingbox); |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 269 | surface->geometry.dirty = 1; |
Kristian Høgsberg | 1e4b86a | 2008-11-23 23:41:08 -0500 | [diff] [blame] | 270 | |
Kristian Høgsberg | 77fb167 | 2010-08-16 10:38:29 -0400 | [diff] [blame] | 271 | return surface; |
Kristian Høgsberg | 5487982 | 2008-11-23 17:07:32 -0500 | [diff] [blame] | 272 | } |
| 273 | |
Alex Wu | 8811bf9 | 2012-02-28 18:07:54 +0800 | [diff] [blame] | 274 | WL_EXPORT void |
Kristian Høgsberg | bbeefb0 | 2012-01-26 10:00:23 -0500 | [diff] [blame] | 275 | weston_surface_set_color(struct weston_surface *surface, |
| 276 | GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) |
| 277 | { |
Kristian Høgsberg | bbeefb0 | 2012-01-26 10:00:23 -0500 | [diff] [blame] | 278 | surface->color[0] = red; |
| 279 | surface->color[1] = green; |
| 280 | surface->color[2] = blue; |
| 281 | surface->color[3] = alpha; |
| 282 | surface->shader = &surface->compositor->solid_shader; |
| 283 | } |
| 284 | |
Kristian Høgsberg | e4c1a5f | 2012-06-18 13:17:32 -0400 | [diff] [blame] | 285 | WL_EXPORT void |
| 286 | weston_surface_to_global_float(struct weston_surface *surface, |
| 287 | GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y) |
Pekka Paalanen | ece8a01 | 2012-02-08 15:23:15 +0200 | [diff] [blame] | 288 | { |
| 289 | if (surface->transform.enabled) { |
| 290 | struct weston_vector v = { { sx, sy, 0.0f, 1.0f } }; |
| 291 | |
| 292 | weston_matrix_transform(&surface->transform.matrix, &v); |
| 293 | |
| 294 | if (fabsf(v.f[3]) < 1e-6) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 295 | weston_log("warning: numerical instability in " |
Pekka Paalanen | ece8a01 | 2012-02-08 15:23:15 +0200 | [diff] [blame] | 296 | "weston_surface_to_global(), divisor = %g\n", |
| 297 | v.f[3]); |
| 298 | *x = 0; |
| 299 | *y = 0; |
| 300 | return; |
| 301 | } |
| 302 | |
| 303 | *x = v.f[0] / v.f[3]; |
| 304 | *y = v.f[1] / v.f[3]; |
| 305 | } else { |
| 306 | *x = sx + surface->geometry.x; |
| 307 | *y = sy + surface->geometry.y; |
| 308 | } |
| 309 | } |
| 310 | |
Kristian Høgsberg | d8bf90c | 2012-02-23 23:03:14 -0500 | [diff] [blame] | 311 | WL_EXPORT void |
Kristian Høgsberg | 323ee04 | 2012-02-17 12:45:43 -0500 | [diff] [blame] | 312 | weston_surface_damage_below(struct weston_surface *surface) |
Pekka Paalanen | 9abf393 | 2012-02-08 14:49:37 +0200 | [diff] [blame] | 313 | { |
Kristian Høgsberg | 1e83212 | 2012-02-28 22:47:14 -0500 | [diff] [blame] | 314 | struct weston_compositor *compositor = surface->compositor; |
| 315 | pixman_region32_t damage; |
Pekka Paalanen | 9abf393 | 2012-02-08 14:49:37 +0200 | [diff] [blame] | 316 | |
Kristian Høgsberg | d553bfc | 2012-06-18 22:37:35 -0400 | [diff] [blame] | 317 | if (surface->plane != WESTON_PLANE_PRIMARY) |
| 318 | return; |
| 319 | |
Kristian Høgsberg | 1e83212 | 2012-02-28 22:47:14 -0500 | [diff] [blame] | 320 | pixman_region32_init(&damage); |
| 321 | pixman_region32_subtract(&damage, &surface->transform.boundingbox, |
| 322 | &surface->clip); |
| 323 | pixman_region32_union(&compositor->damage, |
| 324 | &compositor->damage, &damage); |
| 325 | pixman_region32_fini(&damage); |
Pekka Paalanen | 9abf393 | 2012-02-08 14:49:37 +0200 | [diff] [blame] | 326 | } |
| 327 | |
| 328 | static void |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 329 | surface_compute_bbox(struct weston_surface *surface, int32_t sx, int32_t sy, |
| 330 | int32_t width, int32_t height, |
| 331 | pixman_region32_t *bbox) |
| 332 | { |
Pekka Paalanen | 219b982 | 2012-02-08 15:38:37 +0200 | [diff] [blame] | 333 | GLfloat min_x = HUGE_VALF, min_y = HUGE_VALF; |
| 334 | GLfloat max_x = -HUGE_VALF, max_y = -HUGE_VALF; |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 335 | int32_t s[4][2] = { |
| 336 | { sx, sy }, |
| 337 | { sx, sy + height }, |
| 338 | { sx + width, sy }, |
| 339 | { sx + width, sy + height } |
| 340 | }; |
Pekka Paalanen | 219b982 | 2012-02-08 15:38:37 +0200 | [diff] [blame] | 341 | GLfloat int_x, int_y; |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 342 | int i; |
| 343 | |
| 344 | for (i = 0; i < 4; ++i) { |
Pekka Paalanen | 219b982 | 2012-02-08 15:38:37 +0200 | [diff] [blame] | 345 | GLfloat x, y; |
Kristian Høgsberg | e4c1a5f | 2012-06-18 13:17:32 -0400 | [diff] [blame] | 346 | weston_surface_to_global_float(surface, |
| 347 | s[i][0], s[i][1], &x, &y); |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 348 | if (x < min_x) |
| 349 | min_x = x; |
| 350 | if (x > max_x) |
| 351 | max_x = x; |
| 352 | if (y < min_y) |
| 353 | min_y = y; |
| 354 | if (y > max_y) |
| 355 | max_y = y; |
| 356 | } |
| 357 | |
Pekka Paalanen | 219b982 | 2012-02-08 15:38:37 +0200 | [diff] [blame] | 358 | int_x = floorf(min_x); |
| 359 | int_y = floorf(min_y); |
| 360 | pixman_region32_init_rect(bbox, int_x, int_y, |
| 361 | ceilf(max_x) - int_x, ceilf(max_y) - int_y); |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 362 | } |
| 363 | |
Pekka Paalanen | 80fb08d | 2012-02-08 15:14:17 +0200 | [diff] [blame] | 364 | static void |
| 365 | weston_surface_update_transform_disable(struct weston_surface *surface) |
| 366 | { |
| 367 | surface->transform.enabled = 0; |
| 368 | |
Pekka Paalanen | cc2f868 | 2012-02-13 10:34:04 +0200 | [diff] [blame] | 369 | /* round off fractions when not transformed */ |
| 370 | surface->geometry.x = roundf(surface->geometry.x); |
| 371 | surface->geometry.y = roundf(surface->geometry.y); |
| 372 | |
Pekka Paalanen | 80fb08d | 2012-02-08 15:14:17 +0200 | [diff] [blame] | 373 | pixman_region32_init_rect(&surface->transform.boundingbox, |
| 374 | surface->geometry.x, |
| 375 | surface->geometry.y, |
| 376 | surface->geometry.width, |
| 377 | surface->geometry.height); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 378 | |
Kristian Høgsberg | a416fa1 | 2012-05-21 14:06:52 -0400 | [diff] [blame] | 379 | if (surface->alpha == 1.0) { |
Kristian Høgsberg | 3b4af20 | 2012-02-28 09:19:39 -0500 | [diff] [blame] | 380 | pixman_region32_copy(&surface->transform.opaque, |
| 381 | &surface->opaque); |
| 382 | pixman_region32_translate(&surface->transform.opaque, |
| 383 | surface->geometry.x, |
| 384 | surface->geometry.y); |
| 385 | } |
Pekka Paalanen | 80fb08d | 2012-02-08 15:14:17 +0200 | [diff] [blame] | 386 | } |
| 387 | |
| 388 | static int |
| 389 | weston_surface_update_transform_enable(struct weston_surface *surface) |
Pekka Paalanen | 2a5cecc | 2012-01-20 14:24:25 +0200 | [diff] [blame] | 390 | { |
| 391 | struct weston_matrix *matrix = &surface->transform.matrix; |
| 392 | struct weston_matrix *inverse = &surface->transform.inverse; |
| 393 | struct weston_transform *tform; |
| 394 | |
Pekka Paalanen | 80fb08d | 2012-02-08 15:14:17 +0200 | [diff] [blame] | 395 | surface->transform.enabled = 1; |
| 396 | |
| 397 | /* Otherwise identity matrix, but with x and y translation. */ |
| 398 | surface->transform.position.matrix.d[12] = surface->geometry.x; |
| 399 | surface->transform.position.matrix.d[13] = surface->geometry.y; |
| 400 | |
| 401 | weston_matrix_init(matrix); |
| 402 | wl_list_for_each(tform, &surface->geometry.transformation_list, link) |
| 403 | weston_matrix_multiply(matrix, &tform->matrix); |
| 404 | |
| 405 | if (weston_matrix_invert(inverse, matrix) < 0) { |
| 406 | /* Oops, bad total transformation, not invertible */ |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 407 | weston_log("error: weston_surface %p" |
Pekka Paalanen | 80fb08d | 2012-02-08 15:14:17 +0200 | [diff] [blame] | 408 | " transformation not invertible.\n", surface); |
| 409 | return -1; |
| 410 | } |
| 411 | |
| 412 | surface_compute_bbox(surface, 0, 0, surface->geometry.width, |
| 413 | surface->geometry.height, |
| 414 | &surface->transform.boundingbox); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 415 | |
Pekka Paalanen | 80fb08d | 2012-02-08 15:14:17 +0200 | [diff] [blame] | 416 | return 0; |
| 417 | } |
| 418 | |
| 419 | WL_EXPORT void |
| 420 | weston_surface_update_transform(struct weston_surface *surface) |
| 421 | { |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 422 | if (!surface->geometry.dirty) |
Pekka Paalanen | 2a5cecc | 2012-01-20 14:24:25 +0200 | [diff] [blame] | 423 | return; |
| 424 | |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 425 | surface->geometry.dirty = 0; |
Pekka Paalanen | 2a5cecc | 2012-01-20 14:24:25 +0200 | [diff] [blame] | 426 | |
Kristian Høgsberg | 323ee04 | 2012-02-17 12:45:43 -0500 | [diff] [blame] | 427 | weston_surface_damage_below(surface); |
Pekka Paalanen | 9651678 | 2012-02-09 15:32:15 +0200 | [diff] [blame] | 428 | |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 429 | pixman_region32_fini(&surface->transform.boundingbox); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 430 | pixman_region32_fini(&surface->transform.opaque); |
| 431 | pixman_region32_init(&surface->transform.opaque); |
| 432 | |
| 433 | if (region_is_undefined(&surface->input)) |
| 434 | pixman_region32_init_rect(&surface->input, 0, 0, |
| 435 | surface->geometry.width, |
| 436 | surface->geometry.height); |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 437 | |
Pekka Paalanen | cd40362 | 2012-01-25 13:37:39 +0200 | [diff] [blame] | 438 | /* transform.position is always in transformation_list */ |
| 439 | if (surface->geometry.transformation_list.next == |
| 440 | &surface->transform.position.link && |
| 441 | surface->geometry.transformation_list.prev == |
| 442 | &surface->transform.position.link) { |
Pekka Paalanen | 80fb08d | 2012-02-08 15:14:17 +0200 | [diff] [blame] | 443 | weston_surface_update_transform_disable(surface); |
| 444 | } else { |
| 445 | if (weston_surface_update_transform_enable(surface) < 0) |
| 446 | weston_surface_update_transform_disable(surface); |
Pekka Paalanen | 2a5cecc | 2012-01-20 14:24:25 +0200 | [diff] [blame] | 447 | } |
Pekka Paalanen | 9651678 | 2012-02-09 15:32:15 +0200 | [diff] [blame] | 448 | |
Kristian Høgsberg | f1ea63f | 2012-07-18 12:02:51 -0400 | [diff] [blame] | 449 | weston_surface_damage_below(surface); |
Pekka Paalanen | 9651678 | 2012-02-09 15:32:15 +0200 | [diff] [blame] | 450 | |
Ander Conselvan de Oliveira | b8ab14f | 2012-03-27 17:36:36 +0300 | [diff] [blame] | 451 | if (weston_surface_is_mapped(surface)) |
Pekka Paalanen | f07cb5d | 2012-02-10 13:34:36 +0200 | [diff] [blame] | 452 | weston_surface_assign_output(surface); |
Pekka Paalanen | 2a5cecc | 2012-01-20 14:24:25 +0200 | [diff] [blame] | 453 | } |
| 454 | |
Pekka Paalanen | ddae03c | 2012-02-06 14:54:20 +0200 | [diff] [blame] | 455 | WL_EXPORT void |
Daniel Stone | bd3489b | 2012-05-08 17:17:53 +0100 | [diff] [blame] | 456 | weston_surface_to_global_fixed(struct weston_surface *surface, |
| 457 | wl_fixed_t sx, wl_fixed_t sy, |
| 458 | wl_fixed_t *x, wl_fixed_t *y) |
| 459 | { |
| 460 | GLfloat xf, yf; |
| 461 | |
| 462 | weston_surface_to_global_float(surface, |
| 463 | wl_fixed_to_double(sx), |
| 464 | wl_fixed_to_double(sy), |
| 465 | &xf, &yf); |
| 466 | *x = wl_fixed_from_double(xf); |
| 467 | *y = wl_fixed_from_double(yf); |
| 468 | } |
| 469 | |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 470 | static void |
| 471 | surface_from_global_float(struct weston_surface *surface, |
Daniel Stone | bd3489b | 2012-05-08 17:17:53 +0100 | [diff] [blame] | 472 | GLfloat x, GLfloat y, GLfloat *sx, GLfloat *sy) |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 473 | { |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 474 | if (surface->transform.enabled) { |
| 475 | struct weston_vector v = { { x, y, 0.0f, 1.0f } }; |
| 476 | |
| 477 | weston_matrix_transform(&surface->transform.inverse, &v); |
| 478 | |
| 479 | if (fabsf(v.f[3]) < 1e-6) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 480 | weston_log("warning: numerical instability in " |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 481 | "weston_surface_from_global(), divisor = %g\n", |
| 482 | v.f[3]); |
| 483 | *sx = 0; |
| 484 | *sy = 0; |
| 485 | return; |
| 486 | } |
| 487 | |
Pekka Paalanen | cd40362 | 2012-01-25 13:37:39 +0200 | [diff] [blame] | 488 | *sx = v.f[0] / v.f[3]; |
| 489 | *sy = v.f[1] / v.f[3]; |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 490 | } else { |
Pekka Paalanen | ba3cf95 | 2012-01-25 16:22:05 +0200 | [diff] [blame] | 491 | *sx = x - surface->geometry.x; |
| 492 | *sy = y - surface->geometry.y; |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 493 | } |
| 494 | } |
| 495 | |
| 496 | WL_EXPORT void |
Daniel Stone | bd3489b | 2012-05-08 17:17:53 +0100 | [diff] [blame] | 497 | weston_surface_from_global_fixed(struct weston_surface *surface, |
| 498 | wl_fixed_t x, wl_fixed_t y, |
| 499 | wl_fixed_t *sx, wl_fixed_t *sy) |
| 500 | { |
| 501 | GLfloat sxf, syf; |
| 502 | |
Daniel Stone | bd3489b | 2012-05-08 17:17:53 +0100 | [diff] [blame] | 503 | surface_from_global_float(surface, |
| 504 | wl_fixed_to_double(x), |
| 505 | wl_fixed_to_double(y), |
| 506 | &sxf, &syf); |
| 507 | *sx = wl_fixed_from_double(sxf); |
| 508 | *sy = wl_fixed_from_double(syf); |
| 509 | } |
| 510 | |
| 511 | WL_EXPORT void |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 512 | weston_surface_from_global(struct weston_surface *surface, |
| 513 | int32_t x, int32_t y, int32_t *sx, int32_t *sy) |
| 514 | { |
| 515 | GLfloat sxf, syf; |
| 516 | |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 517 | surface_from_global_float(surface, x, y, &sxf, &syf); |
| 518 | *sx = floorf(sxf); |
| 519 | *sy = floorf(syf); |
| 520 | } |
| 521 | |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 522 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 523 | weston_surface_damage(struct weston_surface *surface) |
Kristian Høgsberg | 31bd6c7 | 2011-02-13 13:00:51 -0500 | [diff] [blame] | 524 | { |
Kristian Høgsberg | 460a79b | 2012-06-18 15:09:11 -0400 | [diff] [blame] | 525 | pixman_region32_union_rect(&surface->damage, &surface->damage, |
| 526 | 0, 0, surface->geometry.width, |
| 527 | surface->geometry.height); |
Pekka Paalanen | 2267d45 | 2012-01-26 13:12:45 +0200 | [diff] [blame] | 528 | |
| 529 | weston_compositor_schedule_repaint(surface->compositor); |
Kristian Høgsberg | 31bd6c7 | 2011-02-13 13:00:51 -0500 | [diff] [blame] | 530 | } |
| 531 | |
Kristian Høgsberg | a691aee | 2011-06-23 21:43:50 -0400 | [diff] [blame] | 532 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 533 | weston_surface_configure(struct weston_surface *surface, |
Pekka Paalanen | ddae03c | 2012-02-06 14:54:20 +0200 | [diff] [blame] | 534 | GLfloat x, GLfloat y, int width, int height) |
Kristian Høgsberg | a691aee | 2011-06-23 21:43:50 -0400 | [diff] [blame] | 535 | { |
Pekka Paalanen | ba3cf95 | 2012-01-25 16:22:05 +0200 | [diff] [blame] | 536 | surface->geometry.x = x; |
| 537 | surface->geometry.y = y; |
Pekka Paalanen | 60921e5 | 2012-01-25 15:55:43 +0200 | [diff] [blame] | 538 | surface->geometry.width = width; |
| 539 | surface->geometry.height = height; |
Pekka Paalanen | cd40362 | 2012-01-25 13:37:39 +0200 | [diff] [blame] | 540 | surface->geometry.dirty = 1; |
Kristian Høgsberg | a691aee | 2011-06-23 21:43:50 -0400 | [diff] [blame] | 541 | } |
| 542 | |
Pekka Paalanen | 8fb8d3b | 2012-02-13 13:03:59 +0200 | [diff] [blame] | 543 | WL_EXPORT void |
| 544 | weston_surface_set_position(struct weston_surface *surface, |
| 545 | GLfloat x, GLfloat y) |
| 546 | { |
| 547 | surface->geometry.x = x; |
| 548 | surface->geometry.y = y; |
| 549 | surface->geometry.dirty = 1; |
| 550 | } |
| 551 | |
Ander Conselvan de Oliveira | b8ab14f | 2012-03-27 17:36:36 +0300 | [diff] [blame] | 552 | WL_EXPORT int |
| 553 | weston_surface_is_mapped(struct weston_surface *surface) |
| 554 | { |
| 555 | if (surface->output) |
| 556 | return 1; |
| 557 | else |
| 558 | return 0; |
| 559 | } |
| 560 | |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 561 | WL_EXPORT uint32_t |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 562 | weston_compositor_get_time(void) |
Kristian Høgsberg | 7132a9a | 2010-12-06 21:41:10 -0500 | [diff] [blame] | 563 | { |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 564 | struct timeval tv; |
Kristian Høgsberg | 7132a9a | 2010-12-06 21:41:10 -0500 | [diff] [blame] | 565 | |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 566 | gettimeofday(&tv, NULL); |
Kristian Høgsberg | 7132a9a | 2010-12-06 21:41:10 -0500 | [diff] [blame] | 567 | |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 568 | return tv.tv_sec * 1000 + tv.tv_usec / 1000; |
Kristian Høgsberg | 7132a9a | 2010-12-06 21:41:10 -0500 | [diff] [blame] | 569 | } |
| 570 | |
Tiago Vignatti | 9d39352 | 2012-02-10 16:26:19 +0200 | [diff] [blame] | 571 | static struct weston_surface * |
| 572 | weston_compositor_pick_surface(struct weston_compositor *compositor, |
Daniel Stone | 103db7f | 2012-05-08 17:17:55 +0100 | [diff] [blame] | 573 | wl_fixed_t x, wl_fixed_t y, |
| 574 | wl_fixed_t *sx, wl_fixed_t *sy) |
Tiago Vignatti | 9d39352 | 2012-02-10 16:26:19 +0200 | [diff] [blame] | 575 | { |
| 576 | struct weston_surface *surface; |
| 577 | |
| 578 | wl_list_for_each(surface, &compositor->surface_list, link) { |
Daniel Stone | 103db7f | 2012-05-08 17:17:55 +0100 | [diff] [blame] | 579 | weston_surface_from_global_fixed(surface, x, y, sx, sy); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 580 | if (pixman_region32_contains_point(&surface->input, |
Daniel Stone | 103db7f | 2012-05-08 17:17:55 +0100 | [diff] [blame] | 581 | wl_fixed_to_int(*sx), |
| 582 | wl_fixed_to_int(*sy), |
| 583 | NULL)) |
Tiago Vignatti | 9d39352 | 2012-02-10 16:26:19 +0200 | [diff] [blame] | 584 | return surface; |
| 585 | } |
| 586 | |
| 587 | return NULL; |
| 588 | } |
| 589 | |
| 590 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 591 | weston_device_repick(struct wl_seat *seat) |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 592 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 593 | struct weston_seat *ws = (struct weston_seat *) seat; |
Scott Moreau | 447013d | 2012-02-18 05:05:29 -0700 | [diff] [blame] | 594 | const struct wl_pointer_grab_interface *interface; |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 595 | struct weston_surface *surface, *focus; |
| 596 | |
Daniel Stone | e9e92d2 | 2012-06-04 11:40:47 +0100 | [diff] [blame] | 597 | if (!seat->pointer) |
| 598 | return; |
| 599 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 600 | surface = weston_compositor_pick_surface(ws->compositor, |
| 601 | seat->pointer->x, |
| 602 | seat->pointer->y, |
| 603 | &seat->pointer->current_x, |
| 604 | &seat->pointer->current_y); |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 605 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 606 | if (&surface->surface != seat->pointer->current) { |
| 607 | interface = seat->pointer->grab->interface; |
Kristian Høgsberg | 4e99ac4 | 2012-06-04 16:12:38 -0400 | [diff] [blame] | 608 | seat->pointer->current = &surface->surface; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 609 | interface->focus(seat->pointer->grab, &surface->surface, |
| 610 | seat->pointer->current_x, |
| 611 | seat->pointer->current_y); |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 612 | } |
| 613 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 614 | focus = (struct weston_surface *) seat->pointer->grab->focus; |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 615 | if (focus) |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 616 | weston_surface_from_global_fixed(focus, |
| 617 | seat->pointer->x, |
| 618 | seat->pointer->y, |
| 619 | &seat->pointer->grab->x, |
| 620 | &seat->pointer->grab->y); |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 621 | } |
| 622 | |
Kristian Høgsberg | 4ff5a74 | 2012-06-18 16:48:27 -0400 | [diff] [blame] | 623 | static void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 624 | weston_compositor_repick(struct weston_compositor *compositor) |
Kristian Høgsberg | d2baf1f | 2011-10-11 22:20:37 -0400 | [diff] [blame] | 625 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 626 | struct weston_seat *seat; |
Kristian Høgsberg | d2baf1f | 2011-10-11 22:20:37 -0400 | [diff] [blame] | 627 | |
Kristian Høgsberg | 1ec0c31 | 2011-11-15 16:39:55 -0500 | [diff] [blame] | 628 | if (!compositor->focus) |
| 629 | return; |
| 630 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 631 | wl_list_for_each(seat, &compositor->seat_list, link) |
| 632 | weston_device_repick(&seat->seat); |
Kristian Høgsberg | d2baf1f | 2011-10-11 22:20:37 -0400 | [diff] [blame] | 633 | } |
| 634 | |
Kristian Høgsberg | af7b1ff | 2012-06-26 21:19:23 -0400 | [diff] [blame] | 635 | WL_EXPORT void |
Kristian Høgsberg | 3b5ea3b | 2012-02-17 12:43:56 -0500 | [diff] [blame] | 636 | weston_surface_unmap(struct weston_surface *surface) |
| 637 | { |
Daniel Stone | 4dab5db | 2012-05-30 16:31:53 +0100 | [diff] [blame] | 638 | struct weston_seat *seat; |
Kristian Høgsberg | 867dec7 | 2012-03-01 17:09:37 -0500 | [diff] [blame] | 639 | |
Kristian Høgsberg | 3b5ea3b | 2012-02-17 12:43:56 -0500 | [diff] [blame] | 640 | weston_surface_damage_below(surface); |
Kristian Høgsberg | 3b5ea3b | 2012-02-17 12:43:56 -0500 | [diff] [blame] | 641 | surface->output = NULL; |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 642 | wl_list_remove(&surface->layer_link); |
Kristian Høgsberg | 867dec7 | 2012-03-01 17:09:37 -0500 | [diff] [blame] | 643 | |
Daniel Stone | 4dab5db | 2012-05-30 16:31:53 +0100 | [diff] [blame] | 644 | wl_list_for_each(seat, &surface->compositor->seat_list, link) { |
Daniel Stone | e9e92d2 | 2012-06-04 11:40:47 +0100 | [diff] [blame] | 645 | if (seat->seat.keyboard && |
| 646 | seat->seat.keyboard->focus == &surface->surface) |
Daniel Stone | 4dab5db | 2012-05-30 16:31:53 +0100 | [diff] [blame] | 647 | wl_keyboard_set_focus(seat->seat.keyboard, NULL); |
Daniel Stone | e9e92d2 | 2012-06-04 11:40:47 +0100 | [diff] [blame] | 648 | if (seat->seat.pointer && |
| 649 | seat->seat.pointer->focus == &surface->surface) |
Daniel Stone | 4dab5db | 2012-05-30 16:31:53 +0100 | [diff] [blame] | 650 | wl_pointer_set_focus(seat->seat.pointer, |
| 651 | NULL, |
| 652 | wl_fixed_from_int(0), |
| 653 | wl_fixed_from_int(0)); |
| 654 | } |
Kristian Høgsberg | 867dec7 | 2012-03-01 17:09:37 -0500 | [diff] [blame] | 655 | |
Kristian Høgsberg | 3b5ea3b | 2012-02-17 12:43:56 -0500 | [diff] [blame] | 656 | weston_compositor_schedule_repaint(surface->compositor); |
| 657 | } |
| 658 | |
Kristian Høgsberg | 1e51fec | 2012-07-22 11:33:14 -0400 | [diff] [blame] | 659 | struct weston_frame_callback { |
| 660 | struct wl_resource resource; |
| 661 | struct wl_list link; |
| 662 | }; |
| 663 | |
Kristian Høgsberg | 3b5ea3b | 2012-02-17 12:43:56 -0500 | [diff] [blame] | 664 | static void |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 665 | destroy_surface(struct wl_resource *resource) |
Kristian Høgsberg | 5487982 | 2008-11-23 17:07:32 -0500 | [diff] [blame] | 666 | { |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 667 | int i; |
| 668 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 669 | struct weston_surface *surface = |
| 670 | container_of(resource, |
| 671 | struct weston_surface, surface.resource); |
| 672 | struct weston_compositor *compositor = surface->compositor; |
Kristian Høgsberg | 1e51fec | 2012-07-22 11:33:14 -0400 | [diff] [blame] | 673 | struct weston_frame_callback *cb, *next; |
Kristian Høgsberg | 4fa4873 | 2009-03-10 23:17:00 -0400 | [diff] [blame] | 674 | |
Ander Conselvan de Oliveira | b8ab14f | 2012-03-27 17:36:36 +0300 | [diff] [blame] | 675 | if (weston_surface_is_mapped(surface)) |
Kristian Høgsberg | 3b5ea3b | 2012-02-17 12:43:56 -0500 | [diff] [blame] | 676 | weston_surface_unmap(surface); |
Kristian Høgsberg | d2baf1f | 2011-10-11 22:20:37 -0400 | [diff] [blame] | 677 | |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 678 | glDeleteTextures(surface->num_textures, surface->textures); |
Benjamin Franzke | 431da9a | 2011-04-20 11:02:58 +0200 | [diff] [blame] | 679 | |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 680 | if (surface->buffer) |
| 681 | wl_list_remove(&surface->buffer_destroy_listener.link); |
Kristian Høgsberg | 3f8f39c | 2009-09-18 17:05:13 -0400 | [diff] [blame] | 682 | |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 683 | for (i = 0; i < surface->num_images; i++) |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 684 | compositor->destroy_image(compositor->egl_display, |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 685 | surface->images[i]); |
Benjamin Franzke | 1178a3c | 2011-04-10 16:49:52 +0200 | [diff] [blame] | 686 | |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 687 | pixman_region32_fini(&surface->transform.boundingbox); |
Pekka Paalanen | 402ae6d | 2012-01-03 10:23:24 +0200 | [diff] [blame] | 688 | pixman_region32_fini(&surface->damage); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 689 | pixman_region32_fini(&surface->opaque); |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 690 | pixman_region32_fini(&surface->clip); |
Kristian Høgsberg | dd631c1 | 2012-02-23 16:20:38 -0500 | [diff] [blame] | 691 | if (!region_is_undefined(&surface->input)) |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 692 | pixman_region32_fini(&surface->input); |
Pekka Paalanen | 402ae6d | 2012-01-03 10:23:24 +0200 | [diff] [blame] | 693 | |
Kristian Høgsberg | 1e51fec | 2012-07-22 11:33:14 -0400 | [diff] [blame] | 694 | wl_list_for_each_safe(cb, next, &surface->frame_callback_list, link) |
| 695 | wl_resource_destroy(&cb->resource); |
| 696 | |
Kristian Høgsberg | 4fa4873 | 2009-03-10 23:17:00 -0400 | [diff] [blame] | 697 | free(surface); |
Kristian Høgsberg | 5487982 | 2008-11-23 17:07:32 -0500 | [diff] [blame] | 698 | } |
| 699 | |
Alex Wu | 8811bf9 | 2012-02-28 18:07:54 +0800 | [diff] [blame] | 700 | WL_EXPORT void |
| 701 | weston_surface_destroy(struct weston_surface *surface) |
| 702 | { |
| 703 | /* Not a valid way to destroy a client surface */ |
| 704 | assert(surface->surface.resource.client == NULL); |
| 705 | |
Kristian Høgsberg | 9a050af | 2012-06-07 18:17:42 -0400 | [diff] [blame] | 706 | wl_signal_emit(&surface->surface.resource.destroy_signal, |
| 707 | &surface->surface.resource); |
Alex Wu | 8811bf9 | 2012-02-28 18:07:54 +0800 | [diff] [blame] | 708 | destroy_surface(&surface->surface.resource); |
| 709 | } |
| 710 | |
Benjamin Franzke | faa0a9d | 2011-02-21 16:24:53 +0100 | [diff] [blame] | 711 | static void |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 712 | ensure_textures(struct weston_surface *es, int num_textures) |
| 713 | { |
| 714 | int i; |
| 715 | |
| 716 | if (num_textures <= es->num_textures) |
| 717 | return; |
| 718 | |
| 719 | for (i = es->num_textures; i < num_textures; i++) { |
| 720 | glGenTextures(1, &es->textures[i]); |
| 721 | glBindTexture(GL_TEXTURE_2D, es->textures[i]); |
| 722 | glTexParameteri(GL_TEXTURE_2D, |
| 723 | GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| 724 | glTexParameteri(GL_TEXTURE_2D, |
| 725 | GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| 726 | } |
| 727 | es->num_textures = num_textures; |
| 728 | glBindTexture(GL_TEXTURE_2D, 0); |
| 729 | } |
| 730 | |
| 731 | static void |
Kristian Høgsberg | 8cbfb2a | 2012-03-27 17:04:59 -0400 | [diff] [blame] | 732 | weston_surface_attach(struct wl_surface *surface, struct wl_buffer *buffer) |
Benjamin Franzke | faa0a9d | 2011-02-21 16:24:53 +0100 | [diff] [blame] | 733 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 734 | struct weston_surface *es = (struct weston_surface *) surface; |
| 735 | struct weston_compositor *ec = es->compositor; |
Kristian Høgsberg | 905d7ce | 2012-07-19 14:20:20 -0400 | [diff] [blame] | 736 | EGLint attribs[3], format; |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 737 | int i, num_planes; |
Benjamin Franzke | faa0a9d | 2011-02-21 16:24:53 +0100 | [diff] [blame] | 738 | |
Ander Conselvan de Oliveira | e11683a | 2012-03-27 17:36:40 +0300 | [diff] [blame] | 739 | if (es->buffer) { |
| 740 | weston_buffer_post_release(es->buffer); |
| 741 | wl_list_remove(&es->buffer_destroy_listener.link); |
| 742 | } |
| 743 | |
| 744 | es->buffer = buffer; |
| 745 | |
| 746 | if (!buffer) { |
| 747 | if (weston_surface_is_mapped(es)) |
| 748 | weston_surface_unmap(es); |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 749 | for (i = 0; i < es->num_images; i++) { |
| 750 | ec->destroy_image(ec->egl_display, es->images[i]); |
| 751 | es->images[i] = NULL; |
Kristian Høgsberg | b8ceaaa | 2012-06-19 15:41:12 -0400 | [diff] [blame] | 752 | } |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 753 | es->num_images = 0; |
| 754 | glDeleteTextures(es->num_textures, es->textures); |
| 755 | es->num_textures = 0; |
Ander Conselvan de Oliveira | e11683a | 2012-03-27 17:36:40 +0300 | [diff] [blame] | 756 | return; |
| 757 | } |
| 758 | |
| 759 | buffer->busy_count++; |
Kristian Høgsberg | 27e3052 | 2012-04-11 23:18:23 -0400 | [diff] [blame] | 760 | wl_signal_add(&es->buffer->resource.destroy_signal, |
| 761 | &es->buffer_destroy_listener); |
Ander Conselvan de Oliveira | e11683a | 2012-03-27 17:36:40 +0300 | [diff] [blame] | 762 | |
| 763 | if (es->geometry.width != buffer->width || |
| 764 | es->geometry.height != buffer->height) { |
| 765 | undef_region(&es->input); |
| 766 | pixman_region32_fini(&es->opaque); |
| 767 | pixman_region32_init(&es->opaque); |
| 768 | } |
| 769 | |
Benjamin Franzke | 315b3dc | 2011-03-08 11:32:57 +0100 | [diff] [blame] | 770 | if (wl_buffer_is_shm(buffer)) { |
Benjamin Franzke | fab5ec1 | 2011-04-25 19:44:47 +0200 | [diff] [blame] | 771 | es->pitch = wl_shm_buffer_get_stride(buffer) / 4; |
Gwenole Beauchesne | 6d03049 | 2012-04-20 11:15:51 +0200 | [diff] [blame] | 772 | es->shader = &ec->texture_shader_rgba; |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 773 | |
| 774 | ensure_textures(es, 1); |
| 775 | glBindTexture(GL_TEXTURE_2D, es->textures[0]); |
Kristian Høgsberg | fb6de22 | 2012-03-27 17:10:13 -0400 | [diff] [blame] | 776 | glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, |
| 777 | es->pitch, es->buffer->height, 0, |
| 778 | GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL); |
Kristian Høgsberg | d6ad122 | 2012-05-17 11:11:15 -0400 | [diff] [blame] | 779 | if (wl_shm_buffer_get_format(buffer) == WL_SHM_FORMAT_XRGB8888) |
| 780 | es->blend = 0; |
| 781 | else |
| 782 | es->blend = 1; |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 783 | } else if (ec->query_buffer(ec->egl_display, buffer, |
Kristian Høgsberg | 905d7ce | 2012-07-19 14:20:20 -0400 | [diff] [blame] | 784 | EGL_TEXTURE_FORMAT, &format)) { |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 785 | for (i = 0; i < es->num_images; i++) |
Kristian Høgsberg | 971cbc8 | 2012-07-17 14:21:25 -0400 | [diff] [blame] | 786 | ec->destroy_image(ec->egl_display, es->images[i]); |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 787 | es->num_images = 0; |
Ander Conselvan de Oliveira | e11683a | 2012-03-27 17:36:40 +0300 | [diff] [blame] | 788 | |
Kristian Høgsberg | 905d7ce | 2012-07-19 14:20:20 -0400 | [diff] [blame] | 789 | switch (format) { |
| 790 | case EGL_TEXTURE_RGB: |
| 791 | case EGL_TEXTURE_RGBA: |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 792 | default: |
| 793 | num_planes = 1; |
| 794 | es->shader = &ec->texture_shader_rgba; |
| 795 | break; |
Kristian Høgsberg | 905d7ce | 2012-07-19 14:20:20 -0400 | [diff] [blame] | 796 | case EGL_TEXTURE_Y_UV_WL: |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 797 | num_planes = 2; |
| 798 | es->shader = &ec->texture_shader_y_uv; |
| 799 | break; |
Kristian Høgsberg | 905d7ce | 2012-07-19 14:20:20 -0400 | [diff] [blame] | 800 | case EGL_TEXTURE_Y_U_V_WL: |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 801 | num_planes = 3; |
| 802 | es->shader = &ec->texture_shader_y_u_v; |
| 803 | break; |
Kristian Høgsberg | 905d7ce | 2012-07-19 14:20:20 -0400 | [diff] [blame] | 804 | case EGL_TEXTURE_Y_XUXV_WL: |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 805 | num_planes = 2; |
| 806 | es->shader = &ec->texture_shader_y_xuxv; |
| 807 | break; |
| 808 | } |
| 809 | |
| 810 | ensure_textures(es, num_planes); |
| 811 | for (i = 0; i < num_planes; i++) { |
| 812 | attribs[0] = EGL_WAYLAND_PLANE_WL; |
| 813 | attribs[1] = i; |
| 814 | attribs[2] = EGL_NONE; |
| 815 | es->images[i] = ec->create_image(ec->egl_display, |
| 816 | NULL, |
| 817 | EGL_WAYLAND_BUFFER_WL, |
| 818 | buffer, attribs); |
| 819 | if (!es->images[i]) |
| 820 | continue; |
| 821 | es->num_images++; |
| 822 | |
| 823 | glActiveTexture(GL_TEXTURE0 + i); |
| 824 | glBindTexture(GL_TEXTURE_2D, es->textures[i]); |
| 825 | ec->image_target_texture_2d(GL_TEXTURE_2D, |
| 826 | es->images[i]); |
| 827 | } |
Kristian Høgsberg | f389cac | 2011-08-31 16:21:38 -0400 | [diff] [blame] | 828 | |
Ander Conselvan de Oliveira | 9390ae3 | 2012-03-27 17:36:38 +0300 | [diff] [blame] | 829 | es->pitch = buffer->width; |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 830 | } else { |
| 831 | /* unhandled buffer type */ |
Benjamin Franzke | faa0a9d | 2011-02-21 16:24:53 +0100 | [diff] [blame] | 832 | } |
| 833 | } |
| 834 | |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 835 | static int |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 836 | texture_region(struct weston_surface *es, pixman_region32_t *region) |
Kristian Høgsberg | 4c9f2c9 | 2008-11-21 19:25:44 -0500 | [diff] [blame] | 837 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 838 | struct weston_compositor *ec = es->compositor; |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 839 | GLfloat *v, inv_width, inv_height; |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 840 | GLfloat sx, sy; |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 841 | pixman_box32_t *rectangles; |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 842 | unsigned int *p; |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 843 | int i, n; |
| 844 | |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 845 | rectangles = pixman_region32_rectangles(region, &n); |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 846 | v = wl_array_add(&ec->vertices, n * 16 * sizeof *v); |
| 847 | p = wl_array_add(&ec->indices, n * 6 * sizeof *p); |
Benjamin Franzke | fab5ec1 | 2011-04-25 19:44:47 +0200 | [diff] [blame] | 848 | inv_width = 1.0 / es->pitch; |
Pekka Paalanen | 60921e5 | 2012-01-25 15:55:43 +0200 | [diff] [blame] | 849 | inv_height = 1.0 / es->geometry.height; |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 850 | |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 851 | for (i = 0; i < n; i++, v += 16, p += 6) { |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 852 | surface_from_global_float(es, rectangles[i].x1, |
| 853 | rectangles[i].y1, &sx, &sy); |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 854 | v[ 0] = rectangles[i].x1; |
| 855 | v[ 1] = rectangles[i].y1; |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 856 | v[ 2] = sx * inv_width; |
| 857 | v[ 3] = sy * inv_height; |
Kristian Høgsberg | fa4e2a7 | 2011-02-13 13:44:55 -0500 | [diff] [blame] | 858 | |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 859 | surface_from_global_float(es, rectangles[i].x1, |
| 860 | rectangles[i].y2, &sx, &sy); |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 861 | v[ 4] = rectangles[i].x1; |
| 862 | v[ 5] = rectangles[i].y2; |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 863 | v[ 6] = sx * inv_width; |
| 864 | v[ 7] = sy * inv_height; |
Kristian Høgsberg | fa4e2a7 | 2011-02-13 13:44:55 -0500 | [diff] [blame] | 865 | |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 866 | surface_from_global_float(es, rectangles[i].x2, |
| 867 | rectangles[i].y1, &sx, &sy); |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 868 | v[ 8] = rectangles[i].x2; |
| 869 | v[ 9] = rectangles[i].y1; |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 870 | v[10] = sx * inv_width; |
| 871 | v[11] = sy * inv_height; |
Kristian Høgsberg | fa4e2a7 | 2011-02-13 13:44:55 -0500 | [diff] [blame] | 872 | |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 873 | surface_from_global_float(es, rectangles[i].x2, |
| 874 | rectangles[i].y2, &sx, &sy); |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 875 | v[12] = rectangles[i].x2; |
| 876 | v[13] = rectangles[i].y2; |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 877 | v[14] = sx * inv_width; |
| 878 | v[15] = sy * inv_height; |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 879 | |
| 880 | p[0] = i * 4 + 0; |
| 881 | p[1] = i * 4 + 1; |
| 882 | p[2] = i * 4 + 2; |
| 883 | p[3] = i * 4 + 2; |
| 884 | p[4] = i * 4 + 1; |
| 885 | p[5] = i * 4 + 3; |
| 886 | } |
Kristian Høgsberg | fa4e2a7 | 2011-02-13 13:44:55 -0500 | [diff] [blame] | 887 | |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 888 | return n; |
| 889 | } |
| 890 | |
Kristian Høgsberg | 68c479a | 2012-01-25 23:32:28 -0500 | [diff] [blame] | 891 | WL_EXPORT void |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 892 | weston_surface_draw(struct weston_surface *es, struct weston_output *output, |
| 893 | pixman_region32_t *damage) |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 894 | { |
Scott Moreau | 9fb9824 | 2012-05-22 10:18:50 -0600 | [diff] [blame] | 895 | GLfloat surface_rect[4] = { 0.0, 1.0, 0.0, 1.0 }; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 896 | struct weston_compositor *ec = es->compositor; |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 897 | GLfloat *v; |
| 898 | pixman_region32_t repaint; |
Kristian Høgsberg | 40caded | 2011-06-20 19:48:16 -0400 | [diff] [blame] | 899 | GLint filter; |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 900 | int i, n; |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 901 | |
Pekka Paalanen | a9f8a21 | 2012-01-26 11:28:08 +0200 | [diff] [blame] | 902 | pixman_region32_init(&repaint); |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 903 | pixman_region32_intersect(&repaint, |
| 904 | &es->transform.boundingbox, damage); |
| 905 | pixman_region32_subtract(&repaint, &repaint, &es->clip); |
Pekka Paalanen | c7b45f6 | 2012-02-06 12:16:07 +0200 | [diff] [blame] | 906 | |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 907 | if (!pixman_region32_not_empty(&repaint)) |
Pekka Paalanen | a9f8a21 | 2012-01-26 11:28:08 +0200 | [diff] [blame] | 908 | goto out; |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 909 | |
Kristian Høgsberg | 101cb65 | 2012-02-17 10:45:16 -0500 | [diff] [blame] | 910 | glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); |
Scott Moreau | 9fb9824 | 2012-05-22 10:18:50 -0600 | [diff] [blame] | 911 | if (es->blend || es->alpha < 1.0) |
Kristian Høgsberg | d6ad122 | 2012-05-17 11:11:15 -0400 | [diff] [blame] | 912 | glEnable(GL_BLEND); |
| 913 | else |
| 914 | glDisable(GL_BLEND); |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 915 | |
Kristian Høgsberg | 0763262 | 2012-01-25 23:02:06 -0500 | [diff] [blame] | 916 | if (ec->current_shader != es->shader) { |
| 917 | glUseProgram(es->shader->program); |
Kristian Høgsberg | 0763262 | 2012-01-25 23:02:06 -0500 | [diff] [blame] | 918 | ec->current_shader = es->shader; |
| 919 | } |
| 920 | |
Kristian Høgsberg | 0452abc | 2012-01-31 15:38:36 -0500 | [diff] [blame] | 921 | glUniformMatrix4fv(es->shader->proj_uniform, |
| 922 | 1, GL_FALSE, output->matrix.d); |
Pekka Paalanen | f55f544 | 2012-02-02 16:49:05 +0200 | [diff] [blame] | 923 | glUniform4fv(es->shader->color_uniform, 1, es->color); |
Kristian Høgsberg | a416fa1 | 2012-05-21 14:06:52 -0400 | [diff] [blame] | 924 | glUniform1f(es->shader->alpha_uniform, es->alpha); |
Pekka Paalanen | f55f544 | 2012-02-02 16:49:05 +0200 | [diff] [blame] | 925 | glUniform1f(es->shader->texwidth_uniform, |
| 926 | (GLfloat)es->geometry.width / es->pitch); |
Scott Moreau | 9fb9824 | 2012-05-22 10:18:50 -0600 | [diff] [blame] | 927 | if (es->blend) |
| 928 | glUniform4fv(es->shader->opaque_uniform, 1, es->opaque_rect); |
| 929 | else |
| 930 | glUniform4fv(es->shader->opaque_uniform, 1, surface_rect); |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 931 | |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 932 | if (es->transform.enabled || output->zoom.active) |
Kristian Høgsberg | 40caded | 2011-06-20 19:48:16 -0400 | [diff] [blame] | 933 | filter = GL_LINEAR; |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 934 | else |
Pekka Paalanen | c61eca6 | 2012-01-06 14:10:06 +0200 | [diff] [blame] | 935 | filter = GL_NEAREST; |
Pekka Paalanen | 0e151bb | 2012-01-24 14:47:37 +0200 | [diff] [blame] | 936 | |
| 937 | n = texture_region(es, &repaint); |
Kristian Høgsberg | 2e94d11 | 2011-05-02 13:47:51 -0400 | [diff] [blame] | 938 | |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 939 | for (i = 0; i < es->num_textures; i++) { |
| 940 | glUniform1i(es->shader->tex_uniforms[i], i); |
| 941 | glActiveTexture(GL_TEXTURE0 + i); |
| 942 | glBindTexture(GL_TEXTURE_2D, es->textures[i]); |
| 943 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter); |
| 944 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter); |
| 945 | } |
Kristian Høgsberg | 40caded | 2011-06-20 19:48:16 -0400 | [diff] [blame] | 946 | |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 947 | v = ec->vertices.data; |
| 948 | glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]); |
| 949 | glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]); |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 950 | glEnableVertexAttribArray(0); |
| 951 | glEnableVertexAttribArray(1); |
Pekka Paalanen | 3df327f | 2012-01-24 15:53:35 +0200 | [diff] [blame] | 952 | |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 953 | glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data); |
| 954 | |
Pekka Paalanen | 3df327f | 2012-01-24 15:53:35 +0200 | [diff] [blame] | 955 | glDisableVertexAttribArray(1); |
| 956 | glDisableVertexAttribArray(0); |
| 957 | |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 958 | ec->vertices.size = 0; |
| 959 | ec->indices.size = 0; |
Pekka Paalanen | a9f8a21 | 2012-01-26 11:28:08 +0200 | [diff] [blame] | 960 | |
| 961 | out: |
Kristian Høgsberg | 525e4c0 | 2011-02-14 10:39:54 -0500 | [diff] [blame] | 962 | pixman_region32_fini(&repaint); |
Kristian Høgsberg | 4c9f2c9 | 2008-11-21 19:25:44 -0500 | [diff] [blame] | 963 | } |
| 964 | |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 965 | WL_EXPORT void |
| 966 | weston_surface_restack(struct weston_surface *surface, struct wl_list *below) |
Kristian Høgsberg | 8da19ac | 2009-03-17 16:12:51 -0400 | [diff] [blame] | 967 | { |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 968 | wl_list_remove(&surface->layer_link); |
| 969 | wl_list_insert(below, &surface->layer_link); |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 970 | weston_surface_damage_below(surface); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 971 | weston_surface_damage(surface); |
Kristian Høgsberg | 8da19ac | 2009-03-17 16:12:51 -0400 | [diff] [blame] | 972 | } |
| 973 | |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 974 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 975 | weston_compositor_damage_all(struct weston_compositor *compositor) |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 976 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 977 | struct weston_output *output; |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 978 | |
| 979 | wl_list_for_each(output, &compositor->output_list, link) |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 980 | weston_output_damage(output); |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 981 | } |
| 982 | |
Kristian Høgsberg | 9f404b7 | 2012-01-26 00:11:01 -0500 | [diff] [blame] | 983 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 984 | weston_buffer_post_release(struct wl_buffer *buffer) |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 985 | { |
Kristian Høgsberg | 2459694 | 2011-10-24 17:51:02 -0400 | [diff] [blame] | 986 | if (--buffer->busy_count > 0) |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 987 | return; |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 988 | |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 989 | assert(buffer->resource.client != NULL); |
Kristian Høgsberg | eccef6a | 2011-11-17 16:46:19 -0500 | [diff] [blame] | 990 | wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE); |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 991 | } |
| 992 | |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 993 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 994 | weston_output_damage(struct weston_output *output) |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 995 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 996 | struct weston_compositor *compositor = output->compositor; |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 997 | |
Kristian Høgsberg | 944236a | 2012-02-28 23:07:47 -0500 | [diff] [blame] | 998 | pixman_region32_union(&compositor->damage, |
| 999 | &compositor->damage, &output->region); |
Kristian Høgsberg | 49952d1 | 2012-06-20 00:35:59 -0400 | [diff] [blame] | 1000 | weston_output_schedule_repaint(output); |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1001 | } |
| 1002 | |
Kristian Høgsberg | 01f941b | 2009-05-27 17:47:15 -0400 | [diff] [blame] | 1003 | static void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1004 | fade_frame(struct weston_animation *animation, |
| 1005 | struct weston_output *output, uint32_t msecs) |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1006 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1007 | struct weston_compositor *compositor = |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1008 | container_of(animation, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1009 | struct weston_compositor, fade.animation); |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1010 | struct weston_surface *surface; |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1011 | |
Scott Moreau | 94b0b0c | 2012-06-14 01:01:56 -0600 | [diff] [blame] | 1012 | if (animation->frame_counter <= 1) |
Scott Moreau | e2949db | 2012-06-11 13:09:23 -0600 | [diff] [blame] | 1013 | compositor->fade.spring.timestamp = msecs; |
| 1014 | |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1015 | surface = compositor->fade.surface; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1016 | weston_spring_update(&compositor->fade.spring, msecs); |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1017 | weston_surface_set_color(surface, 0.0, 0.0, 0.0, |
| 1018 | compositor->fade.spring.current); |
| 1019 | weston_surface_damage(surface); |
| 1020 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1021 | if (weston_spring_done(&compositor->fade.spring)) { |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 1022 | compositor->fade.spring.current = |
| 1023 | compositor->fade.spring.target; |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1024 | wl_list_remove(&animation->link); |
| 1025 | wl_list_init(&animation->link); |
Pekka Paalanen | 2e097ee | 2011-12-02 10:39:49 +0200 | [diff] [blame] | 1026 | |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1027 | if (compositor->fade.spring.current < 0.001) { |
| 1028 | destroy_surface(&surface->surface.resource); |
| 1029 | compositor->fade.surface = NULL; |
| 1030 | } else if (compositor->fade.spring.current > 0.999) { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1031 | compositor->state = WESTON_COMPOSITOR_SLEEPING; |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 1032 | wl_signal_emit(&compositor->lock_signal, compositor); |
Pekka Paalanen | 2e097ee | 2011-12-02 10:39:49 +0200 | [diff] [blame] | 1033 | } |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1034 | } |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1035 | } |
| 1036 | |
Kristian Høgsberg | 460a79b | 2012-06-18 15:09:11 -0400 | [diff] [blame] | 1037 | static void |
| 1038 | update_shm_texture(struct weston_surface *surface) |
| 1039 | { |
| 1040 | #ifdef GL_UNPACK_ROW_LENGTH |
| 1041 | pixman_box32_t *rectangles; |
| 1042 | void *data; |
| 1043 | int i, n; |
| 1044 | #endif |
| 1045 | |
Gwenole Beauchesne | 023f855 | 2012-04-20 11:07:06 +0200 | [diff] [blame] | 1046 | glBindTexture(GL_TEXTURE_2D, surface->textures[0]); |
Kristian Høgsberg | 460a79b | 2012-06-18 15:09:11 -0400 | [diff] [blame] | 1047 | |
| 1048 | if (!surface->compositor->has_unpack_subimage) { |
| 1049 | glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, |
| 1050 | surface->pitch, surface->buffer->height, 0, |
| 1051 | GL_BGRA_EXT, GL_UNSIGNED_BYTE, |
| 1052 | wl_shm_buffer_get_data(surface->buffer)); |
| 1053 | |
| 1054 | return; |
| 1055 | } |
| 1056 | |
| 1057 | #ifdef GL_UNPACK_ROW_LENGTH |
| 1058 | /* Mesa does not define GL_EXT_unpack_subimage */ |
| 1059 | glPixelStorei(GL_UNPACK_ROW_LENGTH, surface->pitch); |
| 1060 | data = wl_shm_buffer_get_data(surface->buffer); |
| 1061 | rectangles = pixman_region32_rectangles(&surface->damage, &n); |
| 1062 | for (i = 0; i < n; i++) { |
| 1063 | glPixelStorei(GL_UNPACK_SKIP_PIXELS, rectangles[i].x1); |
| 1064 | glPixelStorei(GL_UNPACK_SKIP_ROWS, rectangles[i].y1); |
| 1065 | glTexSubImage2D(GL_TEXTURE_2D, 0, |
| 1066 | rectangles[i].x1, rectangles[i].y1, |
Rob Bradford | 8f24156 | 2012-07-02 17:33:40 +0100 | [diff] [blame] | 1067 | rectangles[i].x2 - rectangles[i].x1, |
Kristian Høgsberg | 460a79b | 2012-06-18 15:09:11 -0400 | [diff] [blame] | 1068 | rectangles[i].y2 - rectangles[i].y1, |
| 1069 | GL_BGRA_EXT, GL_UNSIGNED_BYTE, data); |
| 1070 | } |
| 1071 | #endif |
| 1072 | } |
| 1073 | |
| 1074 | static void |
| 1075 | surface_accumulate_damage(struct weston_surface *surface, |
| 1076 | pixman_region32_t *new_damage, |
| 1077 | pixman_region32_t *opaque) |
| 1078 | { |
| 1079 | if (surface->buffer && wl_buffer_is_shm(surface->buffer)) |
| 1080 | update_shm_texture(surface); |
| 1081 | |
| 1082 | if (surface->transform.enabled) { |
| 1083 | pixman_box32_t *extents; |
| 1084 | |
| 1085 | extents = pixman_region32_extents(&surface->damage); |
| 1086 | surface_compute_bbox(surface, extents->x1, extents->y1, |
| 1087 | extents->x2 - extents->x1, |
| 1088 | extents->y2 - extents->y1, |
| 1089 | &surface->damage); |
| 1090 | } else { |
| 1091 | pixman_region32_translate(&surface->damage, |
| 1092 | surface->geometry.x, |
| 1093 | surface->geometry.y); |
| 1094 | } |
| 1095 | |
| 1096 | pixman_region32_subtract(&surface->damage, &surface->damage, opaque); |
| 1097 | pixman_region32_union(new_damage, new_damage, &surface->damage); |
| 1098 | empty_region(&surface->damage); |
| 1099 | pixman_region32_copy(&surface->clip, opaque); |
| 1100 | pixman_region32_union(opaque, opaque, &surface->transform.opaque); |
| 1101 | } |
| 1102 | |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1103 | static void |
Rob Bradford | 0fb7975 | 2012-08-02 15:36:57 +0100 | [diff] [blame] | 1104 | weston_output_repaint(struct weston_output *output, uint32_t msecs) |
Kristian Høgsberg | ef7a9ca | 2008-10-11 21:21:39 -0400 | [diff] [blame] | 1105 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1106 | struct weston_compositor *ec = output->compositor; |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1107 | struct weston_surface *es; |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 1108 | struct weston_layer *layer; |
Kristian Høgsberg | 30c018b | 2012-01-26 08:40:37 -0500 | [diff] [blame] | 1109 | struct weston_animation *animation, *next; |
| 1110 | struct weston_frame_callback *cb, *cnext; |
Jonas Ådahl | db77376 | 2012-06-13 00:01:21 +0200 | [diff] [blame] | 1111 | struct wl_list frame_callback_list; |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 1112 | pixman_region32_t opaque, new_damage, output_damage; |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 1113 | int32_t width, height; |
Kristian Høgsberg | fbdbbdc | 2008-11-28 17:06:06 -0500 | [diff] [blame] | 1114 | |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 1115 | weston_compositor_update_drag_surfaces(ec); |
| 1116 | |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 1117 | width = output->current->width + |
| 1118 | output->border.left + output->border.right; |
| 1119 | height = output->current->height + |
| 1120 | output->border.top + output->border.bottom; |
| 1121 | glViewport(0, 0, width, height); |
Kristian Høgsberg | fdec236 | 2001-01-01 22:23:51 -0500 | [diff] [blame] | 1122 | |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 1123 | /* Rebuild the surface list and update surface transforms up front. */ |
| 1124 | wl_list_init(&ec->surface_list); |
Jonas Ådahl | db77376 | 2012-06-13 00:01:21 +0200 | [diff] [blame] | 1125 | wl_list_init(&frame_callback_list); |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 1126 | wl_list_for_each(layer, &ec->layer_list, link) { |
| 1127 | wl_list_for_each(es, &layer->surface_list, layer_link) { |
| 1128 | weston_surface_update_transform(es); |
| 1129 | wl_list_insert(ec->surface_list.prev, &es->link); |
Jonas Ådahl | db77376 | 2012-06-13 00:01:21 +0200 | [diff] [blame] | 1130 | if (es->output == output) { |
| 1131 | wl_list_insert_list(&frame_callback_list, |
| 1132 | &es->frame_callback_list); |
| 1133 | wl_list_init(&es->frame_callback_list); |
| 1134 | } |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 1135 | } |
| 1136 | } |
Pekka Paalanen | 15d60ef | 2012-01-27 14:38:33 +0200 | [diff] [blame] | 1137 | |
Jesse Barnes | 5308a5e | 2012-02-09 13:12:57 -0800 | [diff] [blame] | 1138 | if (output->assign_planes) |
| 1139 | /* |
| 1140 | * This will queue flips for the fbs and sprites where |
| 1141 | * applicable and clear the damage for those surfaces. |
| 1142 | * The repaint loop below will repaint everything |
| 1143 | * else. |
| 1144 | */ |
| 1145 | output->assign_planes(output); |
| 1146 | |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 1147 | pixman_region32_init(&new_damage); |
| 1148 | pixman_region32_init(&opaque); |
| 1149 | |
Kristian Høgsberg | 460a79b | 2012-06-18 15:09:11 -0400 | [diff] [blame] | 1150 | wl_list_for_each(es, &ec->surface_list, link) |
| 1151 | surface_accumulate_damage(es, &new_damage, &opaque); |
Kristian Høgsberg | a82c486 | 2012-01-26 01:03:58 -0500 | [diff] [blame] | 1152 | |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 1153 | pixman_region32_union(&ec->damage, &ec->damage, &new_damage); |
| 1154 | |
| 1155 | pixman_region32_init(&output_damage); |
| 1156 | pixman_region32_union(&output_damage, |
| 1157 | &ec->damage, &output->previous_damage); |
| 1158 | pixman_region32_copy(&output->previous_damage, &ec->damage); |
| 1159 | pixman_region32_intersect(&output_damage, |
| 1160 | &output_damage, &output->region); |
| 1161 | pixman_region32_subtract(&ec->damage, &ec->damage, &output->region); |
Kristian Høgsberg | 31bd6c7 | 2011-02-13 13:00:51 -0500 | [diff] [blame] | 1162 | |
Kristian Høgsberg | 7341e9b | 2011-07-01 22:12:11 -0400 | [diff] [blame] | 1163 | pixman_region32_fini(&opaque); |
Kristian Høgsberg | 53df1d8 | 2011-06-23 21:11:19 -0400 | [diff] [blame] | 1164 | pixman_region32_fini(&new_damage); |
| 1165 | |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 1166 | if (output->dirty) |
| 1167 | weston_output_update_matrix(output); |
| 1168 | |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 1169 | output->repaint(output, &output_damage); |
Kristian Høgsberg | ef7a9ca | 2008-10-11 21:21:39 -0400 | [diff] [blame] | 1170 | |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 1171 | pixman_region32_fini(&output_damage); |
Kristian Høgsberg | 81ce09a | 2008-12-31 16:18:42 -0500 | [diff] [blame] | 1172 | |
Kristian Høgsberg | ef04414 | 2011-06-21 15:02:12 -0400 | [diff] [blame] | 1173 | output->repaint_needed = 0; |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 1174 | |
Kristian Høgsberg | aa6019e | 2012-03-11 16:35:16 -0400 | [diff] [blame] | 1175 | weston_compositor_repick(ec); |
| 1176 | wl_event_loop_dispatch(ec->input_loop, 0); |
| 1177 | |
Jonas Ådahl | db77376 | 2012-06-13 00:01:21 +0200 | [diff] [blame] | 1178 | wl_list_for_each_safe(cb, cnext, &frame_callback_list, link) { |
Kristian Høgsberg | 0b5cd0c | 2012-03-04 21:57:37 -0500 | [diff] [blame] | 1179 | wl_callback_send_done(&cb->resource, msecs); |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 1180 | wl_resource_destroy(&cb->resource); |
Kristian Høgsberg | 81ce09a | 2008-12-31 16:18:42 -0500 | [diff] [blame] | 1181 | } |
Jonas Ådahl | db77376 | 2012-06-13 00:01:21 +0200 | [diff] [blame] | 1182 | wl_list_init(&frame_callback_list); |
Kristian Høgsberg | 81ce09a | 2008-12-31 16:18:42 -0500 | [diff] [blame] | 1183 | |
Scott Moreau | d64cf21 | 2012-06-08 19:40:54 -0600 | [diff] [blame] | 1184 | wl_list_for_each_safe(animation, next, &output->animation_list, link) { |
Scott Moreau | d64cf21 | 2012-06-08 19:40:54 -0600 | [diff] [blame] | 1185 | animation->frame_counter++; |
Scott Moreau | 94b0b0c | 2012-06-14 01:01:56 -0600 | [diff] [blame] | 1186 | animation->frame(animation, output, msecs); |
Scott Moreau | d64cf21 | 2012-06-08 19:40:54 -0600 | [diff] [blame] | 1187 | } |
Kristian Høgsberg | ef04414 | 2011-06-21 15:02:12 -0400 | [diff] [blame] | 1188 | } |
Kristian Høgsberg | b186847 | 2011-04-22 12:27:57 -0400 | [diff] [blame] | 1189 | |
Kristian Høgsberg | 7dbf5e2 | 2012-03-05 19:50:08 -0500 | [diff] [blame] | 1190 | static int |
| 1191 | weston_compositor_read_input(int fd, uint32_t mask, void *data) |
Kristian Høgsberg | ef04414 | 2011-06-21 15:02:12 -0400 | [diff] [blame] | 1192 | { |
Kristian Høgsberg | 7dbf5e2 | 2012-03-05 19:50:08 -0500 | [diff] [blame] | 1193 | struct weston_compositor *compositor = data; |
Kristian Høgsberg | 34f80ff | 2012-01-18 11:50:31 -0500 | [diff] [blame] | 1194 | |
Kristian Høgsberg | 7dbf5e2 | 2012-03-05 19:50:08 -0500 | [diff] [blame] | 1195 | wl_event_loop_dispatch(compositor->input_loop, 0); |
| 1196 | |
| 1197 | return 1; |
Kristian Høgsberg | ef04414 | 2011-06-21 15:02:12 -0400 | [diff] [blame] | 1198 | } |
| 1199 | |
| 1200 | WL_EXPORT void |
Rob Bradford | 0fb7975 | 2012-08-02 15:36:57 +0100 | [diff] [blame] | 1201 | weston_output_finish_frame(struct weston_output *output, uint32_t msecs) |
Kristian Høgsberg | ef04414 | 2011-06-21 15:02:12 -0400 | [diff] [blame] | 1202 | { |
Kristian Høgsberg | 7dbf5e2 | 2012-03-05 19:50:08 -0500 | [diff] [blame] | 1203 | struct weston_compositor *compositor = output->compositor; |
| 1204 | struct wl_event_loop *loop = |
| 1205 | wl_display_get_event_loop(compositor->wl_display); |
| 1206 | int fd; |
| 1207 | |
Kristian Høgsberg | e9d0492 | 2012-06-19 23:54:26 -0400 | [diff] [blame] | 1208 | output->frame_time = msecs; |
Kristian Høgsberg | 7dbf5e2 | 2012-03-05 19:50:08 -0500 | [diff] [blame] | 1209 | if (output->repaint_needed) { |
Kristian Høgsberg | 30c018b | 2012-01-26 08:40:37 -0500 | [diff] [blame] | 1210 | weston_output_repaint(output, msecs); |
Kristian Høgsberg | 7dbf5e2 | 2012-03-05 19:50:08 -0500 | [diff] [blame] | 1211 | return; |
| 1212 | } |
| 1213 | |
| 1214 | output->repaint_scheduled = 0; |
| 1215 | if (compositor->input_loop_source) |
| 1216 | return; |
| 1217 | |
| 1218 | fd = wl_event_loop_get_fd(compositor->input_loop); |
| 1219 | compositor->input_loop_source = |
| 1220 | wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE, |
| 1221 | weston_compositor_read_input, compositor); |
| 1222 | } |
| 1223 | |
| 1224 | static void |
| 1225 | idle_repaint(void *data) |
| 1226 | { |
| 1227 | struct weston_output *output = data; |
| 1228 | |
| 1229 | weston_output_finish_frame(output, weston_compositor_get_time()); |
Kristian Høgsberg | ef7a9ca | 2008-10-11 21:21:39 -0400 | [diff] [blame] | 1230 | } |
| 1231 | |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 1232 | WL_EXPORT void |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 1233 | weston_layer_init(struct weston_layer *layer, struct wl_list *below) |
| 1234 | { |
| 1235 | wl_list_init(&layer->surface_list); |
Jonas Ådahl | e3cddce | 2012-06-13 00:01:22 +0200 | [diff] [blame] | 1236 | if (below != NULL) |
| 1237 | wl_list_insert(below, &layer->link); |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 1238 | } |
| 1239 | |
| 1240 | WL_EXPORT void |
Kristian Høgsberg | 49952d1 | 2012-06-20 00:35:59 -0400 | [diff] [blame] | 1241 | weston_output_schedule_repaint(struct weston_output *output) |
Kristian Høgsberg | ef7a9ca | 2008-10-11 21:21:39 -0400 | [diff] [blame] | 1242 | { |
Kristian Høgsberg | 49952d1 | 2012-06-20 00:35:59 -0400 | [diff] [blame] | 1243 | struct weston_compositor *compositor = output->compositor; |
Kristian Høgsberg | ef04414 | 2011-06-21 15:02:12 -0400 | [diff] [blame] | 1244 | struct wl_event_loop *loop; |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 1245 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1246 | if (compositor->state == WESTON_COMPOSITOR_SLEEPING) |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1247 | return; |
| 1248 | |
Kristian Høgsberg | ef04414 | 2011-06-21 15:02:12 -0400 | [diff] [blame] | 1249 | loop = wl_display_get_event_loop(compositor->wl_display); |
Kristian Høgsberg | 49952d1 | 2012-06-20 00:35:59 -0400 | [diff] [blame] | 1250 | output->repaint_needed = 1; |
| 1251 | if (output->repaint_scheduled) |
| 1252 | return; |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 1253 | |
Kristian Høgsberg | 49952d1 | 2012-06-20 00:35:59 -0400 | [diff] [blame] | 1254 | wl_event_loop_add_idle(loop, idle_repaint, output); |
| 1255 | output->repaint_scheduled = 1; |
Kristian Høgsberg | 7dbf5e2 | 2012-03-05 19:50:08 -0500 | [diff] [blame] | 1256 | |
| 1257 | if (compositor->input_loop_source) { |
| 1258 | wl_event_source_remove(compositor->input_loop_source); |
| 1259 | compositor->input_loop_source = NULL; |
| 1260 | } |
Kristian Høgsberg | ef7a9ca | 2008-10-11 21:21:39 -0400 | [diff] [blame] | 1261 | } |
Kristian Høgsberg | 5c8c328 | 2009-02-09 15:17:46 -0500 | [diff] [blame] | 1262 | |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 1263 | WL_EXPORT void |
Kristian Høgsberg | 49952d1 | 2012-06-20 00:35:59 -0400 | [diff] [blame] | 1264 | weston_compositor_schedule_repaint(struct weston_compositor *compositor) |
| 1265 | { |
| 1266 | struct weston_output *output; |
| 1267 | |
| 1268 | wl_list_for_each(output, &compositor->output_list, link) |
| 1269 | weston_output_schedule_repaint(output); |
| 1270 | } |
| 1271 | |
| 1272 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1273 | weston_compositor_fade(struct weston_compositor *compositor, float tint) |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1274 | { |
Scott Moreau | 9d1b112 | 2012-06-08 19:40:53 -0600 | [diff] [blame] | 1275 | struct weston_output *output; |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1276 | struct weston_surface *surface; |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1277 | |
Scott Moreau | 9d1b112 | 2012-06-08 19:40:53 -0600 | [diff] [blame] | 1278 | output = container_of(compositor->output_list.next, |
| 1279 | struct weston_output, link); |
| 1280 | |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 1281 | compositor->fade.spring.target = tint; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1282 | if (weston_spring_done(&compositor->fade.spring)) |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1283 | return; |
| 1284 | |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1285 | if (compositor->fade.surface == NULL) { |
Kristian Høgsberg | 18c9300 | 2012-01-27 11:58:31 -0500 | [diff] [blame] | 1286 | surface = weston_surface_create(compositor); |
| 1287 | weston_surface_configure(surface, 0, 0, 8192, 8192); |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1288 | weston_surface_set_color(surface, 0.0, 0.0, 0.0, 0.0); |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 1289 | wl_list_insert(&compositor->fade_layer.surface_list, |
| 1290 | &surface->layer_link); |
Pekka Paalanen | f07cb5d | 2012-02-10 13:34:36 +0200 | [diff] [blame] | 1291 | weston_surface_assign_output(surface); |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1292 | compositor->fade.surface = surface; |
Kristian Høgsberg | 9bc7095 | 2012-02-29 12:22:38 -0500 | [diff] [blame] | 1293 | pixman_region32_init(&surface->input); |
Kristian Høgsberg | 681f9f4 | 2012-01-26 10:55:10 -0500 | [diff] [blame] | 1294 | } |
| 1295 | |
| 1296 | weston_surface_damage(compositor->fade.surface); |
Scott Moreau | d64cf21 | 2012-06-08 19:40:54 -0600 | [diff] [blame] | 1297 | if (wl_list_empty(&compositor->fade.animation.link)) { |
| 1298 | compositor->fade.animation.frame_counter = 0; |
Scott Moreau | 9d1b112 | 2012-06-08 19:40:53 -0600 | [diff] [blame] | 1299 | wl_list_insert(output->animation_list.prev, |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1300 | &compositor->fade.animation.link); |
Scott Moreau | d64cf21 | 2012-06-08 19:40:54 -0600 | [diff] [blame] | 1301 | } |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 1302 | } |
| 1303 | |
Kristian Høgsberg | 5503bf8 | 2008-11-06 10:38:17 -0500 | [diff] [blame] | 1304 | static void |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 1305 | surface_destroy(struct wl_client *client, struct wl_resource *resource) |
Kristian Høgsberg | 16eb675 | 2008-10-08 22:51:32 -0400 | [diff] [blame] | 1306 | { |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 1307 | wl_resource_destroy(resource); |
Kristian Høgsberg | 16eb675 | 2008-10-08 22:51:32 -0400 | [diff] [blame] | 1308 | } |
| 1309 | |
Casey Dahlin | 96d8a75 | 2012-04-19 22:50:07 -0400 | [diff] [blame] | 1310 | static struct wl_resource * |
| 1311 | find_resource_for_client(struct wl_list *list, struct wl_client *client) |
| 1312 | { |
| 1313 | struct wl_resource *r; |
| 1314 | |
| 1315 | wl_list_for_each(r, list, link) { |
| 1316 | if (r->client == client) |
| 1317 | return r; |
| 1318 | } |
| 1319 | |
| 1320 | return NULL; |
| 1321 | } |
| 1322 | |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 1323 | static void |
| 1324 | weston_surface_update_output_mask(struct weston_surface *es, uint32_t mask) |
| 1325 | { |
| 1326 | uint32_t different = es->output_mask ^ mask; |
| 1327 | uint32_t entered = mask & different; |
| 1328 | uint32_t left = es->output_mask & different; |
| 1329 | struct weston_output *output; |
Rob Bradford | 8667e77 | 2012-05-18 14:13:03 +0100 | [diff] [blame] | 1330 | struct wl_resource *resource = NULL; |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 1331 | struct wl_client *client = es->surface.resource.client; |
| 1332 | |
| 1333 | if (es->surface.resource.client == NULL) |
| 1334 | return; |
| 1335 | if (different == 0) |
| 1336 | return; |
| 1337 | |
| 1338 | es->output_mask = mask; |
| 1339 | wl_list_for_each(output, &es->compositor->output_list, link) { |
| 1340 | if (1 << output->id & different) |
| 1341 | resource = |
| 1342 | find_resource_for_client(&output->resource_list, |
| 1343 | client); |
Kristian Høgsberg | c7814d2 | 2012-07-12 12:34:43 -0400 | [diff] [blame] | 1344 | if (resource == NULL) |
| 1345 | continue; |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 1346 | if (1 << output->id & entered) |
| 1347 | wl_surface_send_enter(&es->surface.resource, resource); |
| 1348 | if (1 << output->id & left) |
| 1349 | wl_surface_send_leave(&es->surface.resource, resource); |
| 1350 | } |
| 1351 | } |
| 1352 | |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 1353 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1354 | weston_surface_assign_output(struct weston_surface *es) |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 1355 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1356 | struct weston_compositor *ec = es->compositor; |
| 1357 | struct weston_output *output, *new_output; |
Kristian Høgsberg | 4f0df04 | 2011-07-21 11:30:22 -0700 | [diff] [blame] | 1358 | pixman_region32_t region; |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 1359 | uint32_t max, area, mask; |
Kristian Høgsberg | 4f0df04 | 2011-07-21 11:30:22 -0700 | [diff] [blame] | 1360 | pixman_box32_t *e; |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 1361 | |
Kristian Høgsberg | 496433b | 2011-11-15 13:50:21 -0500 | [diff] [blame] | 1362 | new_output = NULL; |
Kristian Høgsberg | 4f0df04 | 2011-07-21 11:30:22 -0700 | [diff] [blame] | 1363 | max = 0; |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 1364 | mask = 0; |
Pekka Paalanen | 45f3e40 | 2012-01-26 11:34:16 +0200 | [diff] [blame] | 1365 | pixman_region32_init(®ion); |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 1366 | wl_list_for_each(output, &ec->output_list, link) { |
Pekka Paalanen | 45f3e40 | 2012-01-26 11:34:16 +0200 | [diff] [blame] | 1367 | pixman_region32_intersect(®ion, &es->transform.boundingbox, |
| 1368 | &output->region); |
Kristian Høgsberg | 4f0df04 | 2011-07-21 11:30:22 -0700 | [diff] [blame] | 1369 | |
| 1370 | e = pixman_region32_extents(®ion); |
| 1371 | area = (e->x2 - e->x1) * (e->y2 - e->y1); |
| 1372 | |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 1373 | if (area > 0) |
| 1374 | mask |= 1 << output->id; |
| 1375 | |
Kristian Høgsberg | 4f0df04 | 2011-07-21 11:30:22 -0700 | [diff] [blame] | 1376 | if (area >= max) { |
Kristian Høgsberg | 496433b | 2011-11-15 13:50:21 -0500 | [diff] [blame] | 1377 | new_output = output; |
Kristian Høgsberg | 4f0df04 | 2011-07-21 11:30:22 -0700 | [diff] [blame] | 1378 | max = area; |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 1379 | } |
| 1380 | } |
Pekka Paalanen | 45f3e40 | 2012-01-26 11:34:16 +0200 | [diff] [blame] | 1381 | pixman_region32_fini(®ion); |
Kristian Høgsberg | 496433b | 2011-11-15 13:50:21 -0500 | [diff] [blame] | 1382 | |
| 1383 | es->output = new_output; |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 1384 | weston_surface_update_output_mask(es, mask); |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 1385 | } |
| 1386 | |
Kristian Høgsberg | 5503bf8 | 2008-11-06 10:38:17 -0500 | [diff] [blame] | 1387 | static void |
Ander Conselvan de Oliveira | e11683a | 2012-03-27 17:36:40 +0300 | [diff] [blame] | 1388 | surface_attach(struct wl_client *client, |
| 1389 | struct wl_resource *resource, |
| 1390 | struct wl_resource *buffer_resource, int32_t sx, int32_t sy) |
| 1391 | { |
| 1392 | struct weston_surface *es = resource->data; |
| 1393 | struct wl_buffer *buffer = NULL; |
| 1394 | |
| 1395 | if (buffer_resource) |
| 1396 | buffer = buffer_resource->data; |
Kristian Høgsberg | a691aee | 2011-06-23 21:43:50 -0400 | [diff] [blame] | 1397 | |
Kristian Høgsberg | 8cbfb2a | 2012-03-27 17:04:59 -0400 | [diff] [blame] | 1398 | weston_surface_attach(&es->surface, buffer); |
Ander Conselvan de Oliveira | e11683a | 2012-03-27 17:36:40 +0300 | [diff] [blame] | 1399 | |
Ander Conselvan de Oliveira | 093bfa3 | 2012-03-27 17:36:41 +0300 | [diff] [blame] | 1400 | if (buffer && es->configure) |
| 1401 | es->configure(es, sx, sy); |
Kristian Høgsberg | f921289 | 2008-10-11 18:40:23 -0400 | [diff] [blame] | 1402 | } |
| 1403 | |
Kristian Høgsberg | 5503bf8 | 2008-11-06 10:38:17 -0500 | [diff] [blame] | 1404 | static void |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1405 | surface_damage(struct wl_client *client, |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 1406 | struct wl_resource *resource, |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1407 | int32_t x, int32_t y, int32_t width, int32_t height) |
Kristian Høgsberg | 7f77bd8 | 2008-11-07 08:39:37 -0500 | [diff] [blame] | 1408 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1409 | struct weston_surface *es = resource->data; |
Kristian Høgsberg | 9d69f8e | 2010-09-03 14:46:38 -0400 | [diff] [blame] | 1410 | |
Kristian Høgsberg | 460a79b | 2012-06-18 15:09:11 -0400 | [diff] [blame] | 1411 | pixman_region32_union_rect(&es->damage, &es->damage, |
| 1412 | x, y, width, height); |
Kristian Høgsberg | 9629fe3 | 2012-03-26 15:56:39 -0400 | [diff] [blame] | 1413 | |
Kristian Høgsberg | 460a79b | 2012-06-18 15:09:11 -0400 | [diff] [blame] | 1414 | weston_compositor_schedule_repaint(es->compositor); |
Kristian Høgsberg | fbdbbdc | 2008-11-28 17:06:06 -0500 | [diff] [blame] | 1415 | } |
| 1416 | |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 1417 | static void |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 1418 | destroy_frame_callback(struct wl_resource *resource) |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 1419 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1420 | struct weston_frame_callback *cb = resource->data; |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 1421 | |
| 1422 | wl_list_remove(&cb->link); |
Pekka Paalanen | 8c19645 | 2011-11-15 11:45:42 +0200 | [diff] [blame] | 1423 | free(cb); |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 1424 | } |
| 1425 | |
| 1426 | static void |
| 1427 | surface_frame(struct wl_client *client, |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 1428 | struct wl_resource *resource, uint32_t callback) |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 1429 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1430 | struct weston_frame_callback *cb; |
| 1431 | struct weston_surface *es = resource->data; |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 1432 | |
| 1433 | cb = malloc(sizeof *cb); |
| 1434 | if (cb == NULL) { |
Kristian Høgsberg | 9ebcf94 | 2011-09-01 09:54:57 -0400 | [diff] [blame] | 1435 | wl_resource_post_no_memory(resource); |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 1436 | return; |
| 1437 | } |
| 1438 | |
| 1439 | cb->resource.object.interface = &wl_callback_interface; |
| 1440 | cb->resource.object.id = callback; |
| 1441 | cb->resource.destroy = destroy_frame_callback; |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 1442 | cb->resource.client = client; |
| 1443 | cb->resource.data = cb; |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 1444 | |
| 1445 | wl_client_add_resource(client, &cb->resource); |
Jonas Ådahl | db77376 | 2012-06-13 00:01:21 +0200 | [diff] [blame] | 1446 | wl_list_insert(es->frame_callback_list.prev, &cb->link); |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 1447 | } |
| 1448 | |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 1449 | static void |
| 1450 | surface_set_opaque_region(struct wl_client *client, |
| 1451 | struct wl_resource *resource, |
| 1452 | struct wl_resource *region_resource) |
| 1453 | { |
| 1454 | struct weston_surface *surface = resource->data; |
| 1455 | struct weston_region *region; |
| 1456 | |
| 1457 | pixman_region32_fini(&surface->opaque); |
| 1458 | |
| 1459 | if (region_resource) { |
| 1460 | region = region_resource->data; |
| 1461 | pixman_region32_init_rect(&surface->opaque, 0, 0, |
| 1462 | surface->geometry.width, |
| 1463 | surface->geometry.height); |
| 1464 | pixman_region32_intersect(&surface->opaque, |
| 1465 | &surface->opaque, ®ion->region); |
| 1466 | } else { |
| 1467 | pixman_region32_init(&surface->opaque); |
| 1468 | } |
| 1469 | |
| 1470 | surface->geometry.dirty = 1; |
| 1471 | } |
| 1472 | |
| 1473 | static void |
| 1474 | surface_set_input_region(struct wl_client *client, |
| 1475 | struct wl_resource *resource, |
| 1476 | struct wl_resource *region_resource) |
| 1477 | { |
| 1478 | struct weston_surface *surface = resource->data; |
Kristian Høgsberg | 010f98b | 2012-02-23 17:30:45 -0500 | [diff] [blame] | 1479 | struct weston_region *region; |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 1480 | |
| 1481 | if (region_resource) { |
| 1482 | region = region_resource->data; |
| 1483 | pixman_region32_init_rect(&surface->input, 0, 0, |
| 1484 | surface->geometry.width, |
| 1485 | surface->geometry.height); |
| 1486 | pixman_region32_intersect(&surface->input, |
| 1487 | &surface->input, ®ion->region); |
| 1488 | } else { |
| 1489 | pixman_region32_init_rect(&surface->input, 0, 0, |
| 1490 | surface->geometry.width, |
| 1491 | surface->geometry.height); |
| 1492 | } |
| 1493 | |
Kristian Høgsberg | aa6019e | 2012-03-11 16:35:16 -0400 | [diff] [blame] | 1494 | weston_compositor_schedule_repaint(surface->compositor); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 1495 | } |
| 1496 | |
Kristian Høgsberg | 875ab9e | 2012-03-30 11:52:39 -0400 | [diff] [blame] | 1497 | static const struct wl_surface_interface surface_interface = { |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1498 | surface_destroy, |
| 1499 | surface_attach, |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 1500 | surface_damage, |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 1501 | surface_frame, |
| 1502 | surface_set_opaque_region, |
| 1503 | surface_set_input_region |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1504 | }; |
| 1505 | |
| 1506 | static void |
| 1507 | compositor_create_surface(struct wl_client *client, |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 1508 | struct wl_resource *resource, uint32_t id) |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1509 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1510 | struct weston_compositor *ec = resource->data; |
| 1511 | struct weston_surface *surface; |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1512 | |
Kristian Høgsberg | 18c9300 | 2012-01-27 11:58:31 -0500 | [diff] [blame] | 1513 | surface = weston_surface_create(ec); |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 1514 | if (surface == NULL) { |
Kristian Høgsberg | 9ebcf94 | 2011-09-01 09:54:57 -0400 | [diff] [blame] | 1515 | wl_resource_post_no_memory(resource); |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1516 | return; |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 1517 | } |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1518 | |
Kristian Høgsberg | b313b02 | 2010-12-01 17:07:41 -0500 | [diff] [blame] | 1519 | surface->surface.resource.destroy = destroy_surface; |
Kristian Høgsberg | f66d0f4 | 2010-09-02 20:27:16 -0400 | [diff] [blame] | 1520 | |
Kristian Høgsberg | b313b02 | 2010-12-01 17:07:41 -0500 | [diff] [blame] | 1521 | surface->surface.resource.object.id = id; |
| 1522 | surface->surface.resource.object.interface = &wl_surface_interface; |
| 1523 | surface->surface.resource.object.implementation = |
Kristian Høgsberg | f66d0f4 | 2010-09-02 20:27:16 -0400 | [diff] [blame] | 1524 | (void (**)(void)) &surface_interface; |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 1525 | surface->surface.resource.data = surface; |
Kristian Høgsberg | f66d0f4 | 2010-09-02 20:27:16 -0400 | [diff] [blame] | 1526 | |
Kristian Høgsberg | b313b02 | 2010-12-01 17:07:41 -0500 | [diff] [blame] | 1527 | wl_client_add_resource(client, &surface->surface.resource); |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1528 | } |
| 1529 | |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 1530 | static void |
| 1531 | destroy_region(struct wl_resource *resource) |
| 1532 | { |
| 1533 | struct weston_region *region = |
| 1534 | container_of(resource, struct weston_region, resource); |
| 1535 | |
| 1536 | pixman_region32_fini(®ion->region); |
| 1537 | free(region); |
| 1538 | } |
| 1539 | |
| 1540 | static void |
| 1541 | region_destroy(struct wl_client *client, struct wl_resource *resource) |
| 1542 | { |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 1543 | wl_resource_destroy(resource); |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 1544 | } |
| 1545 | |
| 1546 | static void |
| 1547 | region_add(struct wl_client *client, struct wl_resource *resource, |
| 1548 | int32_t x, int32_t y, int32_t width, int32_t height) |
| 1549 | { |
| 1550 | struct weston_region *region = resource->data; |
| 1551 | |
| 1552 | pixman_region32_union_rect(®ion->region, ®ion->region, |
| 1553 | x, y, width, height); |
| 1554 | } |
| 1555 | |
| 1556 | static void |
| 1557 | region_subtract(struct wl_client *client, struct wl_resource *resource, |
| 1558 | int32_t x, int32_t y, int32_t width, int32_t height) |
| 1559 | { |
| 1560 | struct weston_region *region = resource->data; |
| 1561 | pixman_region32_t rect; |
| 1562 | |
| 1563 | pixman_region32_init_rect(&rect, x, y, width, height); |
| 1564 | pixman_region32_subtract(®ion->region, ®ion->region, &rect); |
| 1565 | pixman_region32_fini(&rect); |
| 1566 | } |
| 1567 | |
| 1568 | static const struct wl_region_interface region_interface = { |
| 1569 | region_destroy, |
| 1570 | region_add, |
| 1571 | region_subtract |
| 1572 | }; |
| 1573 | |
| 1574 | static void |
| 1575 | compositor_create_region(struct wl_client *client, |
| 1576 | struct wl_resource *resource, uint32_t id) |
| 1577 | { |
| 1578 | struct weston_region *region; |
| 1579 | |
| 1580 | region = malloc(sizeof *region); |
| 1581 | if (region == NULL) { |
| 1582 | wl_resource_post_no_memory(resource); |
| 1583 | return; |
| 1584 | } |
| 1585 | |
| 1586 | region->resource.destroy = destroy_region; |
| 1587 | |
| 1588 | region->resource.object.id = id; |
| 1589 | region->resource.object.interface = &wl_region_interface; |
| 1590 | region->resource.object.implementation = |
| 1591 | (void (**)(void)) ®ion_interface; |
| 1592 | region->resource.data = region; |
| 1593 | |
| 1594 | pixman_region32_init(®ion->region); |
| 1595 | |
| 1596 | wl_client_add_resource(client, ®ion->resource); |
| 1597 | } |
| 1598 | |
Kristian Høgsberg | 875ab9e | 2012-03-30 11:52:39 -0400 | [diff] [blame] | 1599 | static const struct wl_compositor_interface compositor_interface = { |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1600 | compositor_create_surface, |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 1601 | compositor_create_region |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 1602 | }; |
| 1603 | |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 1604 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1605 | weston_compositor_wake(struct weston_compositor *compositor) |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1606 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1607 | compositor->state = WESTON_COMPOSITOR_ACTIVE; |
| 1608 | weston_compositor_fade(compositor, 0.0); |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1609 | |
| 1610 | wl_event_source_timer_update(compositor->idle_source, |
Pekka Paalanen | 7296e79 | 2011-12-07 16:22:00 +0200 | [diff] [blame] | 1611 | compositor->idle_time * 1000); |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1612 | } |
| 1613 | |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 1614 | static void |
| 1615 | weston_compositor_dpms_on(struct weston_compositor *compositor) |
| 1616 | { |
| 1617 | struct weston_output *output; |
| 1618 | |
| 1619 | wl_list_for_each(output, &compositor->output_list, link) |
| 1620 | if (output->set_dpms) |
| 1621 | output->set_dpms(output, WESTON_DPMS_ON); |
| 1622 | } |
| 1623 | |
Kristian Høgsberg | af867cc | 2011-11-15 13:34:49 +0200 | [diff] [blame] | 1624 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1625 | weston_compositor_activity(struct weston_compositor *compositor) |
Kristian Høgsberg | af867cc | 2011-11-15 13:34:49 +0200 | [diff] [blame] | 1626 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1627 | if (compositor->state == WESTON_COMPOSITOR_ACTIVE) { |
| 1628 | weston_compositor_wake(compositor); |
Kristian Høgsberg | af867cc | 2011-11-15 13:34:49 +0200 | [diff] [blame] | 1629 | } else { |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 1630 | weston_compositor_dpms_on(compositor); |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 1631 | wl_signal_emit(&compositor->unlock_signal, compositor); |
Kristian Høgsberg | af867cc | 2011-11-15 13:34:49 +0200 | [diff] [blame] | 1632 | } |
| 1633 | } |
| 1634 | |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1635 | static void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1636 | weston_compositor_idle_inhibit(struct weston_compositor *compositor) |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1637 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1638 | weston_compositor_activity(compositor); |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1639 | compositor->idle_inhibit++; |
| 1640 | } |
| 1641 | |
| 1642 | static void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1643 | weston_compositor_idle_release(struct weston_compositor *compositor) |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1644 | { |
| 1645 | compositor->idle_inhibit--; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1646 | weston_compositor_activity(compositor); |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1647 | } |
| 1648 | |
| 1649 | static int |
| 1650 | idle_handler(void *data) |
| 1651 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1652 | struct weston_compositor *compositor = data; |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1653 | |
| 1654 | if (compositor->idle_inhibit) |
| 1655 | return 1; |
| 1656 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1657 | weston_compositor_fade(compositor, 1.0); |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1658 | |
| 1659 | return 1; |
| 1660 | } |
| 1661 | |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 1662 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1663 | weston_seat_update_drag_surface(struct wl_seat *seat, int dx, int dy); |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 1664 | |
Kristian Høgsberg | 1f37601 | 2012-05-09 11:43:11 -0400 | [diff] [blame] | 1665 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1666 | clip_pointer_motion(struct weston_seat *seat, wl_fixed_t *fx, wl_fixed_t *fy) |
Kristian Høgsberg | 715a081 | 2008-12-10 10:42:04 -0500 | [diff] [blame] | 1667 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1668 | struct weston_compositor *ec = seat->compositor; |
Kristian Høgsberg | 34829de | 2012-05-09 22:21:14 -0400 | [diff] [blame] | 1669 | struct weston_output *output, *prev = NULL; |
| 1670 | int x, y, old_x, old_y, valid = 0; |
Kristian Høgsberg | 715a081 | 2008-12-10 10:42:04 -0500 | [diff] [blame] | 1671 | |
Kristian Høgsberg | 34829de | 2012-05-09 22:21:14 -0400 | [diff] [blame] | 1672 | x = wl_fixed_to_int(*fx); |
| 1673 | y = wl_fixed_to_int(*fy); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1674 | old_x = wl_fixed_to_int(seat->seat.pointer->x); |
| 1675 | old_y = wl_fixed_to_int(seat->seat.pointer->y); |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1676 | |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 1677 | wl_list_for_each(output, &ec->output_list, link) { |
Kristian Høgsberg | 34829de | 2012-05-09 22:21:14 -0400 | [diff] [blame] | 1678 | if (pixman_region32_contains_point(&output->region, |
| 1679 | x, y, NULL)) |
| 1680 | valid = 1; |
| 1681 | if (pixman_region32_contains_point(&output->region, |
| 1682 | old_x, old_y, NULL)) |
| 1683 | prev = output; |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 1684 | } |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1685 | |
Kristian Høgsberg | 34829de | 2012-05-09 22:21:14 -0400 | [diff] [blame] | 1686 | if (!valid) { |
| 1687 | if (x < prev->x) |
| 1688 | *fx = wl_fixed_from_int(prev->x); |
| 1689 | else if (x >= prev->x + prev->current->width) |
| 1690 | *fx = wl_fixed_from_int(prev->x + |
| 1691 | prev->current->width - 1); |
| 1692 | if (y < prev->y) |
| 1693 | *fy = wl_fixed_from_int(prev->y); |
| 1694 | else if (y >= prev->y + prev->current->height) |
| 1695 | *fy = wl_fixed_from_int(prev->y + |
| 1696 | prev->current->height - 1); |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 1697 | } |
Kristian Høgsberg | 1f37601 | 2012-05-09 11:43:11 -0400 | [diff] [blame] | 1698 | } |
| 1699 | |
| 1700 | WL_EXPORT void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1701 | notify_motion(struct wl_seat *seat, uint32_t time, wl_fixed_t x, wl_fixed_t y) |
Kristian Høgsberg | 1f37601 | 2012-05-09 11:43:11 -0400 | [diff] [blame] | 1702 | { |
| 1703 | const struct wl_pointer_grab_interface *interface; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1704 | struct weston_seat *ws = (struct weston_seat *) seat; |
| 1705 | struct weston_compositor *ec = ws->compositor; |
Kristian Høgsberg | 1f37601 | 2012-05-09 11:43:11 -0400 | [diff] [blame] | 1706 | struct weston_output *output; |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 1707 | int32_t ix, iy; |
Kristian Høgsberg | 1f37601 | 2012-05-09 11:43:11 -0400 | [diff] [blame] | 1708 | |
| 1709 | weston_compositor_activity(ec); |
| 1710 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1711 | clip_pointer_motion(ws, &x, &y); |
Kristian Høgsberg | 1f37601 | 2012-05-09 11:43:11 -0400 | [diff] [blame] | 1712 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1713 | weston_seat_update_drag_surface(seat, |
| 1714 | x - seat->pointer->x, |
| 1715 | y - seat->pointer->y); |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 1716 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1717 | seat->pointer->x = x; |
| 1718 | seat->pointer->y = y; |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 1719 | |
| 1720 | ix = wl_fixed_to_int(x); |
| 1721 | iy = wl_fixed_to_int(y); |
Kristian Høgsberg | db6c2f3 | 2009-02-22 21:51:24 -0500 | [diff] [blame] | 1722 | |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 1723 | wl_list_for_each(output, &ec->output_list, link) |
| 1724 | if (output->zoom.active && |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 1725 | pixman_region32_contains_point(&output->region, |
| 1726 | ix, iy, NULL)) |
Scott Moreau | 8dacaab | 2012-06-17 18:10:58 -0600 | [diff] [blame] | 1727 | weston_output_update_zoom(output, ZOOM_FOCUS_POINTER); |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 1728 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1729 | weston_device_repick(seat); |
| 1730 | interface = seat->pointer->grab->interface; |
| 1731 | interface->motion(seat->pointer->grab, time, |
| 1732 | seat->pointer->grab->x, seat->pointer->grab->y); |
Kristian Høgsberg | 715a081 | 2008-12-10 10:42:04 -0500 | [diff] [blame] | 1733 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1734 | if (ws->sprite) { |
| 1735 | weston_surface_set_position(ws->sprite, |
| 1736 | ix - ws->hotspot_x, |
| 1737 | iy - ws->hotspot_y); |
Pekka Paalanen | f8c6aae | 2012-02-13 11:01:59 +0200 | [diff] [blame] | 1738 | weston_compositor_schedule_repaint(ec); |
Kristian Høgsberg | cd9ac1d | 2011-12-15 09:14:34 -0500 | [diff] [blame] | 1739 | } |
Kristian Høgsberg | 715a081 | 2008-12-10 10:42:04 -0500 | [diff] [blame] | 1740 | } |
| 1741 | |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 1742 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1743 | weston_surface_activate(struct weston_surface *surface, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1744 | struct weston_seat *seat) |
Kristian Høgsberg | c9824dd | 2011-02-06 16:54:59 -0500 | [diff] [blame] | 1745 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1746 | struct weston_compositor *compositor = seat->compositor; |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 1747 | |
Pekka Paalanen | bdc7cd0 | 2012-06-07 15:07:07 +0300 | [diff] [blame] | 1748 | if (seat->seat.keyboard) { |
| 1749 | wl_keyboard_set_focus(seat->seat.keyboard, &surface->surface); |
| 1750 | wl_data_device_set_keyboard_focus(&seat->seat); |
Daniel Stone | 351eb61 | 2012-05-31 15:27:47 -0400 | [diff] [blame] | 1751 | } |
| 1752 | |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 1753 | wl_signal_emit(&compositor->activate_signal, surface); |
Kristian Høgsberg | c9824dd | 2011-02-06 16:54:59 -0500 | [diff] [blame] | 1754 | } |
| 1755 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 1756 | WL_EXPORT void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1757 | notify_button(struct wl_seat *seat, uint32_t time, int32_t button, |
Daniel Stone | 4dbadb1 | 2012-05-30 16:31:51 +0100 | [diff] [blame] | 1758 | enum wl_pointer_button_state state) |
Kristian Høgsberg | eac149a | 2008-12-10 00:24:18 -0500 | [diff] [blame] | 1759 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1760 | struct weston_seat *ws = (struct weston_seat *) seat; |
| 1761 | struct weston_compositor *compositor = ws->compositor; |
| 1762 | struct weston_surface *focus = |
| 1763 | (struct weston_surface *) seat->pointer->focus; |
Scott Moreau | ff1db4a | 2012-04-17 19:06:18 -0600 | [diff] [blame] | 1764 | uint32_t serial = wl_display_next_serial(compositor->wl_display); |
Kristian Høgsberg | ea08115 | 2010-12-07 08:59:51 -0500 | [diff] [blame] | 1765 | |
Daniel Stone | 4dbadb1 | 2012-05-30 16:31:51 +0100 | [diff] [blame] | 1766 | if (state == WL_POINTER_BUTTON_STATE_PRESSED) { |
Scott Moreau | ff1db4a | 2012-04-17 19:06:18 -0600 | [diff] [blame] | 1767 | if (compositor->ping_handler && focus) |
| 1768 | compositor->ping_handler(focus, serial); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1769 | weston_compositor_idle_inhibit(compositor); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1770 | if (seat->pointer->button_count == 0) { |
| 1771 | seat->pointer->grab_button = button; |
| 1772 | seat->pointer->grab_time = time; |
| 1773 | seat->pointer->grab_x = seat->pointer->x; |
| 1774 | seat->pointer->grab_y = seat->pointer->y; |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 1775 | } |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1776 | seat->pointer->button_count++; |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 1777 | } else { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1778 | weston_compositor_idle_release(compositor); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1779 | seat->pointer->button_count--; |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 1780 | } |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1781 | |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1782 | weston_compositor_run_button_binding(compositor, ws, time, button, |
| 1783 | state); |
Kristian Høgsberg | b3fc757 | 2010-12-08 11:07:57 -0500 | [diff] [blame] | 1784 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1785 | seat->pointer->grab->interface->button(seat->pointer->grab, time, |
| 1786 | button, state); |
Kristian Høgsberg | 5a5f007 | 2011-12-19 14:54:11 -0500 | [diff] [blame] | 1787 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1788 | if (seat->pointer->button_count == 1) |
| 1789 | seat->pointer->grab_serial = |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 1790 | wl_display_get_serial(compositor->wl_display); |
Kristian Høgsberg | eac149a | 2008-12-10 00:24:18 -0500 | [diff] [blame] | 1791 | } |
| 1792 | |
Scott Moreau | 210d079 | 2012-03-22 10:47:01 -0600 | [diff] [blame] | 1793 | WL_EXPORT void |
Daniel Stone | 878f0b7 | 2012-05-30 16:31:57 +0100 | [diff] [blame] | 1794 | notify_axis(struct wl_seat *seat, uint32_t time, uint32_t axis, |
| 1795 | wl_fixed_t value) |
Scott Moreau | 210d079 | 2012-03-22 10:47:01 -0600 | [diff] [blame] | 1796 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1797 | struct weston_seat *ws = (struct weston_seat *) seat; |
| 1798 | struct weston_compositor *compositor = ws->compositor; |
| 1799 | struct weston_surface *focus = |
| 1800 | (struct weston_surface *) seat->pointer->focus; |
Scott Moreau | ff1db4a | 2012-04-17 19:06:18 -0600 | [diff] [blame] | 1801 | uint32_t serial = wl_display_next_serial(compositor->wl_display); |
| 1802 | |
| 1803 | if (compositor->ping_handler && focus) |
| 1804 | compositor->ping_handler(focus, serial); |
Scott Moreau | 210d079 | 2012-03-22 10:47:01 -0600 | [diff] [blame] | 1805 | |
| 1806 | weston_compositor_activity(compositor); |
| 1807 | |
Scott Moreau | 6a3633d | 2012-03-20 08:47:59 -0600 | [diff] [blame] | 1808 | if (value) |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1809 | weston_compositor_run_axis_binding(compositor, ws, time, axis, |
Daniel Stone | 0c1e46e | 2012-05-30 16:31:59 +0100 | [diff] [blame] | 1810 | value); |
Scott Moreau | 6a3633d | 2012-03-20 08:47:59 -0600 | [diff] [blame] | 1811 | else |
| 1812 | return; |
| 1813 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1814 | if (seat->pointer->focus_resource) |
Daniel Stone | 878f0b7 | 2012-05-30 16:31:57 +0100 | [diff] [blame] | 1815 | wl_pointer_send_axis(seat->pointer->focus_resource, time, axis, |
Daniel Stone | 2fce402 | 2012-05-30 16:32:00 +0100 | [diff] [blame] | 1816 | value); |
Scott Moreau | 210d079 | 2012-03-22 10:47:01 -0600 | [diff] [blame] | 1817 | } |
| 1818 | |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 1819 | WL_EXPORT void |
| 1820 | notify_modifiers(struct wl_seat *wl_seat, uint32_t serial) |
Kristian Høgsberg | cddc0ad | 2008-11-24 00:31:49 -0500 | [diff] [blame] | 1821 | { |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 1822 | struct weston_seat *seat = (struct weston_seat *) wl_seat; |
| 1823 | struct wl_keyboard *keyboard = &seat->keyboard; |
| 1824 | struct wl_keyboard_grab *grab = keyboard->grab; |
Daniel Stone | 7ace390 | 2012-05-30 16:31:40 +0100 | [diff] [blame] | 1825 | uint32_t mods_depressed, mods_latched, mods_locked, group; |
Daniel Stone | e3f15ed | 2012-05-30 16:31:44 +0100 | [diff] [blame] | 1826 | uint32_t mods_lookup; |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 1827 | enum weston_led leds = 0; |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 1828 | int changed = 0; |
Daniel Stone | 7ace390 | 2012-05-30 16:31:40 +0100 | [diff] [blame] | 1829 | |
Daniel Stone | e3f15ed | 2012-05-30 16:31:44 +0100 | [diff] [blame] | 1830 | /* Serialize and update our internal state, checking to see if it's |
| 1831 | * different to the previous state. */ |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 1832 | mods_depressed = xkb_state_serialize_mods(seat->xkb_state.state, |
| 1833 | XKB_STATE_DEPRESSED); |
| 1834 | mods_latched = xkb_state_serialize_mods(seat->xkb_state.state, |
| 1835 | XKB_STATE_LATCHED); |
| 1836 | mods_locked = xkb_state_serialize_mods(seat->xkb_state.state, |
| 1837 | XKB_STATE_LOCKED); |
| 1838 | group = xkb_state_serialize_group(seat->xkb_state.state, |
Daniel Stone | 7ace390 | 2012-05-30 16:31:40 +0100 | [diff] [blame] | 1839 | XKB_STATE_EFFECTIVE); |
| 1840 | |
Daniel Stone | 71c3877 | 2012-06-22 13:21:30 +0100 | [diff] [blame] | 1841 | if (mods_depressed != seat->seat.keyboard->modifiers.mods_depressed || |
| 1842 | mods_latched != seat->seat.keyboard->modifiers.mods_latched || |
| 1843 | mods_locked != seat->seat.keyboard->modifiers.mods_locked || |
| 1844 | group != seat->seat.keyboard->modifiers.group) |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 1845 | changed = 1; |
Daniel Stone | 7ace390 | 2012-05-30 16:31:40 +0100 | [diff] [blame] | 1846 | |
Daniel Stone | 71c3877 | 2012-06-22 13:21:30 +0100 | [diff] [blame] | 1847 | seat->seat.keyboard->modifiers.mods_depressed = mods_depressed; |
| 1848 | seat->seat.keyboard->modifiers.mods_latched = mods_latched; |
| 1849 | seat->seat.keyboard->modifiers.mods_locked = mods_locked; |
| 1850 | seat->seat.keyboard->modifiers.group = group; |
Kristian Høgsberg | ab909ae | 2001-01-01 22:24:24 -0500 | [diff] [blame] | 1851 | |
Daniel Stone | e3f15ed | 2012-05-30 16:31:44 +0100 | [diff] [blame] | 1852 | /* And update the modifier_state for bindings. */ |
| 1853 | mods_lookup = mods_depressed | mods_latched; |
| 1854 | seat->modifier_state = 0; |
Daniel Stone | 8db7969 | 2012-06-01 12:13:58 +0100 | [diff] [blame] | 1855 | if (mods_lookup & (1 << seat->xkb_info.ctrl_mod)) |
Daniel Stone | e3f15ed | 2012-05-30 16:31:44 +0100 | [diff] [blame] | 1856 | seat->modifier_state |= MODIFIER_CTRL; |
Daniel Stone | 8db7969 | 2012-06-01 12:13:58 +0100 | [diff] [blame] | 1857 | if (mods_lookup & (1 << seat->xkb_info.alt_mod)) |
Daniel Stone | e3f15ed | 2012-05-30 16:31:44 +0100 | [diff] [blame] | 1858 | seat->modifier_state |= MODIFIER_ALT; |
Daniel Stone | 8db7969 | 2012-06-01 12:13:58 +0100 | [diff] [blame] | 1859 | if (mods_lookup & (1 << seat->xkb_info.super_mod)) |
Daniel Stone | e3f15ed | 2012-05-30 16:31:44 +0100 | [diff] [blame] | 1860 | seat->modifier_state |= MODIFIER_SUPER; |
Kristian Høgsberg | 73694c8 | 2012-06-28 14:13:10 -0400 | [diff] [blame] | 1861 | if (mods_lookup & (1 << seat->xkb_info.shift_mod)) |
| 1862 | seat->modifier_state |= MODIFIER_SHIFT; |
Daniel Stone | 7ace390 | 2012-05-30 16:31:40 +0100 | [diff] [blame] | 1863 | |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 1864 | /* Finally, notify the compositor that LEDs have changed. */ |
| 1865 | if (xkb_state_led_index_is_active(seat->xkb_state.state, |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 1866 | seat->xkb_info.num_led)) |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 1867 | leds |= LED_NUM_LOCK; |
| 1868 | if (xkb_state_led_index_is_active(seat->xkb_state.state, |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 1869 | seat->xkb_info.caps_led)) |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 1870 | leds |= LED_CAPS_LOCK; |
| 1871 | if (xkb_state_led_index_is_active(seat->xkb_state.state, |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 1872 | seat->xkb_info.scroll_led)) |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 1873 | leds |= LED_SCROLL_LOCK; |
| 1874 | if (leds != seat->xkb_state.leds && seat->led_update) |
Daniel Stone | bbf63bf | 2012-06-04 11:40:48 +0100 | [diff] [blame] | 1875 | seat->led_update(seat, leds); |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 1876 | seat->xkb_state.leds = leds; |
| 1877 | |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 1878 | if (changed) { |
| 1879 | grab->interface->modifiers(grab, |
| 1880 | serial, |
| 1881 | keyboard->modifiers.mods_depressed, |
| 1882 | keyboard->modifiers.mods_latched, |
| 1883 | keyboard->modifiers.mods_locked, |
| 1884 | keyboard->modifiers.group); |
| 1885 | } |
Kristian Høgsberg | f512d07 | 2011-04-12 17:16:00 -0400 | [diff] [blame] | 1886 | } |
Kristian Høgsberg | 2cbedd1 | 2009-09-18 17:29:49 -0400 | [diff] [blame] | 1887 | |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 1888 | static void |
| 1889 | update_modifier_state(struct weston_seat *seat, uint32_t serial, uint32_t key, |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 1890 | enum wl_keyboard_key_state state) |
| 1891 | { |
| 1892 | enum xkb_key_direction direction; |
| 1893 | |
| 1894 | if (state == WL_KEYBOARD_KEY_STATE_PRESSED) |
| 1895 | direction = XKB_KEY_DOWN; |
| 1896 | else |
| 1897 | direction = XKB_KEY_UP; |
| 1898 | |
| 1899 | /* Offset the keycode by 8, as the evdev XKB rules reflect X's |
| 1900 | * broken keycode system, which starts at 8. */ |
| 1901 | xkb_state_update_key(seat->xkb_state.state, key + 8, direction); |
| 1902 | |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 1903 | notify_modifiers(&seat->seat, serial); |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 1904 | } |
| 1905 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 1906 | WL_EXPORT void |
Daniel Stone | c9785ea | 2012-05-30 16:31:52 +0100 | [diff] [blame] | 1907 | notify_key(struct wl_seat *seat, uint32_t time, uint32_t key, |
Daniel Stone | 1b4e11f | 2012-06-22 13:21:37 +0100 | [diff] [blame] | 1908 | enum wl_keyboard_key_state state, |
| 1909 | enum weston_key_state_update update_state) |
Kristian Høgsberg | f512d07 | 2011-04-12 17:16:00 -0400 | [diff] [blame] | 1910 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1911 | struct weston_seat *ws = (struct weston_seat *) seat; |
| 1912 | struct weston_compositor *compositor = ws->compositor; |
| 1913 | struct weston_surface *focus = |
Kristian Høgsberg | 8fe8d24 | 2012-06-22 16:57:21 -0400 | [diff] [blame] | 1914 | (struct weston_surface *) seat->keyboard->focus; |
Daniel Stone | 7ace390 | 2012-05-30 16:31:40 +0100 | [diff] [blame] | 1915 | struct wl_keyboard_grab *grab = seat->keyboard->grab; |
Scott Moreau | ff1db4a | 2012-04-17 19:06:18 -0600 | [diff] [blame] | 1916 | uint32_t serial = wl_display_next_serial(compositor->wl_display); |
Kristian Høgsberg | f512d07 | 2011-04-12 17:16:00 -0400 | [diff] [blame] | 1917 | uint32_t *k, *end; |
Kristian Høgsberg | f512d07 | 2011-04-12 17:16:00 -0400 | [diff] [blame] | 1918 | |
Daniel Stone | c9785ea | 2012-05-30 16:31:52 +0100 | [diff] [blame] | 1919 | if (state == WL_KEYBOARD_KEY_STATE_PRESSED) { |
Scott Moreau | ff1db4a | 2012-04-17 19:06:18 -0600 | [diff] [blame] | 1920 | if (compositor->ping_handler && focus) |
| 1921 | compositor->ping_handler(focus, serial); |
| 1922 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1923 | weston_compositor_idle_inhibit(compositor); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1924 | seat->keyboard->grab_key = key; |
| 1925 | seat->keyboard->grab_time = time; |
Scott Moreau | ec286eb | 2012-02-18 05:05:30 -0700 | [diff] [blame] | 1926 | } else { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1927 | weston_compositor_idle_release(compositor); |
Scott Moreau | ec286eb | 2012-02-18 05:05:30 -0700 | [diff] [blame] | 1928 | } |
Kristian Høgsberg | e10a5d9 | 2011-04-22 14:01:18 -0400 | [diff] [blame] | 1929 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1930 | end = seat->keyboard->keys.data + seat->keyboard->keys.size; |
| 1931 | for (k = seat->keyboard->keys.data; k < end; k++) { |
Daniel Stone | c6587ea | 2012-06-22 13:21:31 +0100 | [diff] [blame] | 1932 | if (*k == key) { |
| 1933 | /* Ignore server-generated repeats. */ |
| 1934 | if (state == WL_KEYBOARD_KEY_STATE_PRESSED) |
| 1935 | return; |
Kristian Høgsberg | 3c38fa0 | 2009-02-23 22:30:29 -0500 | [diff] [blame] | 1936 | *k = *--end; |
Daniel Stone | c6587ea | 2012-06-22 13:21:31 +0100 | [diff] [blame] | 1937 | } |
Kristian Høgsberg | 3c38fa0 | 2009-02-23 22:30:29 -0500 | [diff] [blame] | 1938 | } |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1939 | seat->keyboard->keys.size = (void *) end - seat->keyboard->keys.data; |
Daniel Stone | c9785ea | 2012-05-30 16:31:52 +0100 | [diff] [blame] | 1940 | if (state == WL_KEYBOARD_KEY_STATE_PRESSED) { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1941 | k = wl_array_add(&seat->keyboard->keys, sizeof *k); |
Kristian Høgsberg | 3c38fa0 | 2009-02-23 22:30:29 -0500 | [diff] [blame] | 1942 | *k = key; |
| 1943 | } |
Ray Strode | e96dcb8 | 2008-12-20 02:00:49 -0500 | [diff] [blame] | 1944 | |
Scott Moreau | befa653 | 2012-06-11 14:59:31 -0600 | [diff] [blame] | 1945 | if (grab == &seat->keyboard->default_grab) { |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1946 | weston_compositor_run_key_binding(compositor, ws, time, key, |
| 1947 | state); |
Scott Moreau | befa653 | 2012-06-11 14:59:31 -0600 | [diff] [blame] | 1948 | grab = seat->keyboard->grab; |
| 1949 | } |
Kristian Høgsberg | abcef3c | 2012-03-05 17:47:15 -0500 | [diff] [blame] | 1950 | |
Daniel Stone | 7ace390 | 2012-05-30 16:31:40 +0100 | [diff] [blame] | 1951 | grab->interface->key(grab, time, key, state); |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 1952 | |
| 1953 | if (update_state == STATE_UPDATE_AUTOMATIC) { |
| 1954 | update_modifier_state(ws, |
| 1955 | wl_display_get_serial(compositor->wl_display), |
| 1956 | key, |
| 1957 | state); |
| 1958 | } |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 1959 | } |
| 1960 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 1961 | WL_EXPORT void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1962 | notify_pointer_focus(struct wl_seat *seat, struct weston_output *output, |
| 1963 | wl_fixed_t x, wl_fixed_t y) |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 1964 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1965 | struct weston_seat *ws = (struct weston_seat *) seat; |
| 1966 | struct weston_compositor *compositor = ws->compositor; |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 1967 | |
| 1968 | if (output) { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1969 | weston_seat_update_drag_surface(seat, |
| 1970 | x - seat->pointer->x, |
| 1971 | y - seat->pointer->y); |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 1972 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1973 | seat->pointer->x = x; |
| 1974 | seat->pointer->y = y; |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 1975 | compositor->focus = 1; |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 1976 | weston_compositor_repick(compositor); |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 1977 | } else { |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 1978 | compositor->focus = 0; |
Tiago Vignatti | cd717b5 | 2012-07-12 00:46:10 +0300 | [diff] [blame] | 1979 | /* FIXME: We should call wl_pointer_set_focus(seat, |
| 1980 | * NULL) here, but somehow that breaks re-entry... */ |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 1981 | } |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 1982 | } |
| 1983 | |
Ander Conselvan de Oliveira | 71b1d0c | 2012-03-16 17:25:11 +0200 | [diff] [blame] | 1984 | static void |
Kristian Høgsberg | 27e3052 | 2012-04-11 23:18:23 -0400 | [diff] [blame] | 1985 | destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data) |
Ander Conselvan de Oliveira | 71b1d0c | 2012-03-16 17:25:11 +0200 | [diff] [blame] | 1986 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1987 | struct weston_seat *ws; |
Ander Conselvan de Oliveira | 71b1d0c | 2012-03-16 17:25:11 +0200 | [diff] [blame] | 1988 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1989 | ws = container_of(listener, struct weston_seat, |
Ander Conselvan de Oliveira | 71b1d0c | 2012-03-16 17:25:11 +0200 | [diff] [blame] | 1990 | saved_kbd_focus_listener); |
| 1991 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1992 | ws->saved_kbd_focus = NULL; |
Ander Conselvan de Oliveira | 71b1d0c | 2012-03-16 17:25:11 +0200 | [diff] [blame] | 1993 | } |
| 1994 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 1995 | WL_EXPORT void |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 1996 | notify_keyboard_focus_in(struct wl_seat *seat, struct wl_array *keys, |
| 1997 | enum weston_key_state_update update_state) |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 1998 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1999 | struct weston_seat *ws = (struct weston_seat *) seat; |
| 2000 | struct weston_compositor *compositor = ws->compositor; |
Kristian Høgsberg | afee221 | 2012-03-20 17:28:20 -0400 | [diff] [blame] | 2001 | struct wl_surface *surface; |
Kristian Høgsberg | c7cd626 | 2012-06-28 13:46:09 -0400 | [diff] [blame] | 2002 | uint32_t *k, serial; |
Kristian Høgsberg | f992b2f | 2011-01-28 15:53:07 -0500 | [diff] [blame] | 2003 | |
Kristian Høgsberg | c7cd626 | 2012-06-28 13:46:09 -0400 | [diff] [blame] | 2004 | serial = wl_display_next_serial(compositor->wl_display); |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 2005 | wl_array_copy(&seat->keyboard->keys, keys); |
| 2006 | wl_array_for_each(k, &seat->keyboard->keys) { |
| 2007 | weston_compositor_idle_inhibit(compositor); |
| 2008 | if (update_state == STATE_UPDATE_AUTOMATIC) |
Kristian Høgsberg | c7cd626 | 2012-06-28 13:46:09 -0400 | [diff] [blame] | 2009 | update_modifier_state(ws, serial, *k, |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 2010 | WL_KEYBOARD_KEY_STATE_PRESSED); |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 2011 | } |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 2012 | |
Daniel Stone | ef17267 | 2012-06-22 13:21:32 +0100 | [diff] [blame] | 2013 | /* Run key bindings after we've updated the state. */ |
| 2014 | wl_array_for_each(k, &seat->keyboard->keys) { |
| 2015 | weston_compositor_run_key_binding(compositor, ws, 0, *k, |
| 2016 | WL_KEYBOARD_KEY_STATE_PRESSED); |
| 2017 | } |
| 2018 | |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 2019 | surface = ws->saved_kbd_focus; |
| 2020 | |
| 2021 | if (surface) { |
| 2022 | wl_list_remove(&ws->saved_kbd_focus_listener.link); |
| 2023 | wl_keyboard_set_focus(ws->seat.keyboard, surface); |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 2024 | ws->saved_kbd_focus = NULL; |
| 2025 | } |
| 2026 | } |
| 2027 | |
| 2028 | WL_EXPORT void |
| 2029 | notify_keyboard_focus_out(struct wl_seat *seat) |
| 2030 | { |
| 2031 | struct weston_seat *ws = (struct weston_seat *) seat; |
| 2032 | struct weston_compositor *compositor = ws->compositor; |
| 2033 | struct wl_surface *surface; |
Kristian Høgsberg | c7cd626 | 2012-06-28 13:46:09 -0400 | [diff] [blame] | 2034 | uint32_t *k, serial; |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 2035 | |
Kristian Høgsberg | c7cd626 | 2012-06-28 13:46:09 -0400 | [diff] [blame] | 2036 | serial = wl_display_next_serial(compositor->wl_display); |
| 2037 | wl_array_for_each(k, &seat->keyboard->keys) { |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 2038 | weston_compositor_idle_release(compositor); |
Kristian Høgsberg | c7cd626 | 2012-06-28 13:46:09 -0400 | [diff] [blame] | 2039 | update_modifier_state(ws, serial, *k, |
| 2040 | WL_KEYBOARD_KEY_STATE_RELEASED); |
| 2041 | } |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 2042 | |
| 2043 | ws->modifier_state = 0; |
| 2044 | |
| 2045 | surface = ws->seat.keyboard->focus; |
| 2046 | |
| 2047 | if (surface) { |
| 2048 | ws->saved_kbd_focus = surface; |
| 2049 | ws->saved_kbd_focus_listener.notify = |
| 2050 | destroy_device_saved_kbd_focus; |
| 2051 | wl_signal_add(&surface->resource.destroy_signal, |
| 2052 | &ws->saved_kbd_focus_listener); |
| 2053 | } |
| 2054 | |
| 2055 | wl_keyboard_set_focus(ws->seat.keyboard, NULL); |
| 2056 | /* FIXME: We really need keyboard grab cancel here to |
| 2057 | * let the grab shut down properly. As it is we leak |
| 2058 | * the grab data. */ |
| 2059 | wl_keyboard_end_grab(ws->seat.keyboard); |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 2060 | } |
| 2061 | |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2062 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2063 | touch_set_focus(struct weston_seat *ws, struct wl_surface *surface) |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2064 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2065 | struct wl_seat *seat = &ws->seat; |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2066 | struct wl_resource *resource; |
| 2067 | |
Pekka Paalanen | 5646425 | 2012-07-31 13:21:08 +0300 | [diff] [blame] | 2068 | if (seat->touch->focus == surface) |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2069 | return; |
| 2070 | |
Pekka Paalanen | 5646425 | 2012-07-31 13:21:08 +0300 | [diff] [blame] | 2071 | if (seat->touch->focus_resource) |
| 2072 | wl_list_remove(&seat->touch->focus_listener.link); |
| 2073 | seat->touch->focus = NULL; |
| 2074 | seat->touch->focus_resource = NULL; |
| 2075 | |
Kristian Høgsberg | 03cb5cf | 2011-12-22 14:43:09 -0500 | [diff] [blame] | 2076 | if (surface) { |
| 2077 | resource = |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2078 | find_resource_for_client(&seat->touch->resource_list, |
Casey Dahlin | 96d8a75 | 2012-04-19 22:50:07 -0400 | [diff] [blame] | 2079 | surface->resource.client); |
Kristian Høgsberg | 03cb5cf | 2011-12-22 14:43:09 -0500 | [diff] [blame] | 2080 | if (!resource) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 2081 | weston_log("couldn't find resource\n"); |
Kristian Høgsberg | 03cb5cf | 2011-12-22 14:43:09 -0500 | [diff] [blame] | 2082 | return; |
| 2083 | } |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2084 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2085 | seat->touch->focus = surface; |
| 2086 | seat->touch->focus_resource = resource; |
Pekka Paalanen | 5646425 | 2012-07-31 13:21:08 +0300 | [diff] [blame] | 2087 | wl_signal_add(&resource->destroy_signal, |
| 2088 | &seat->touch->focus_listener); |
Kristian Høgsberg | 03cb5cf | 2011-12-22 14:43:09 -0500 | [diff] [blame] | 2089 | } |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2090 | } |
| 2091 | |
Tiago Vignatti | 22c6bce | 2011-12-21 19:34:09 +0200 | [diff] [blame] | 2092 | /** |
| 2093 | * notify_touch - emulates button touches and notifies surfaces accordingly. |
| 2094 | * |
| 2095 | * It assumes always the correct cycle sequence until it gets here: touch_down |
| 2096 | * → touch_update → ... → touch_update → touch_end. The driver is responsible |
| 2097 | * for sending along such order. |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2098 | * |
Tiago Vignatti | 22c6bce | 2011-12-21 19:34:09 +0200 | [diff] [blame] | 2099 | */ |
| 2100 | WL_EXPORT void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2101 | notify_touch(struct wl_seat *seat, uint32_t time, int touch_id, |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 2102 | wl_fixed_t x, wl_fixed_t y, int touch_type) |
Tiago Vignatti | 22c6bce | 2011-12-21 19:34:09 +0200 | [diff] [blame] | 2103 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2104 | struct weston_seat *ws = (struct weston_seat *) seat; |
| 2105 | struct weston_compositor *ec = ws->compositor; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 2106 | struct weston_surface *es; |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 2107 | wl_fixed_t sx, sy; |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 2108 | uint32_t serial = 0; |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2109 | |
| 2110 | switch (touch_type) { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2111 | case WL_TOUCH_DOWN: |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 2112 | weston_compositor_idle_inhibit(ec); |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2113 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2114 | ws->num_tp++; |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2115 | |
| 2116 | /* the first finger down picks the surface, and all further go |
| 2117 | * to that surface for the remainder of the touch session i.e. |
| 2118 | * until all touch points are up again. */ |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2119 | if (ws->num_tp == 1) { |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 2120 | es = weston_compositor_pick_surface(ec, x, y, &sx, &sy); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2121 | touch_set_focus(ws, &es->surface); |
Pekka Paalanen | 5646425 | 2012-07-31 13:21:08 +0300 | [diff] [blame] | 2122 | } else if (seat->touch->focus) { |
| 2123 | es = (struct weston_surface *)seat->touch->focus; |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 2124 | weston_surface_from_global_fixed(es, x, y, &sx, &sy); |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2125 | } |
Kristian Høgsberg | 03cb5cf | 2011-12-22 14:43:09 -0500 | [diff] [blame] | 2126 | |
Pekka Paalanen | 5646425 | 2012-07-31 13:21:08 +0300 | [diff] [blame] | 2127 | if (seat->touch->focus_resource && seat->touch->focus) |
| 2128 | wl_touch_send_down(seat->touch->focus_resource, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2129 | serial, time, |
Pekka Paalanen | 5646425 | 2012-07-31 13:21:08 +0300 | [diff] [blame] | 2130 | &seat->touch->focus->resource, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2131 | touch_id, sx, sy); |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2132 | break; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2133 | case WL_TOUCH_MOTION: |
Pekka Paalanen | 5646425 | 2012-07-31 13:21:08 +0300 | [diff] [blame] | 2134 | es = (struct weston_surface *)seat->touch->focus; |
Kristian Høgsberg | 03cb5cf | 2011-12-22 14:43:09 -0500 | [diff] [blame] | 2135 | if (!es) |
| 2136 | break; |
| 2137 | |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 2138 | weston_surface_from_global_fixed(es, x, y, &sx, &sy); |
Pekka Paalanen | 5646425 | 2012-07-31 13:21:08 +0300 | [diff] [blame] | 2139 | if (seat->touch->focus_resource) |
| 2140 | wl_touch_send_motion(seat->touch->focus_resource, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2141 | time, touch_id, sx, sy); |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2142 | break; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2143 | case WL_TOUCH_UP: |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 2144 | weston_compositor_idle_release(ec); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2145 | ws->num_tp--; |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2146 | |
Pekka Paalanen | 5646425 | 2012-07-31 13:21:08 +0300 | [diff] [blame] | 2147 | if (seat->touch->focus_resource) |
| 2148 | wl_touch_send_up(seat->touch->focus_resource, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2149 | serial, time, touch_id); |
| 2150 | if (ws->num_tp == 0) |
| 2151 | touch_set_focus(ws, NULL); |
Tiago Vignatti | 1f221ff | 2011-12-21 19:34:10 +0200 | [diff] [blame] | 2152 | break; |
| 2153 | } |
Tiago Vignatti | 22c6bce | 2011-12-21 19:34:09 +0200 | [diff] [blame] | 2154 | } |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 2155 | |
Kristian Høgsberg | 77fb167 | 2010-08-16 10:38:29 -0400 | [diff] [blame] | 2156 | static void |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2157 | pointer_handle_sprite_destroy(struct wl_listener *listener, void *data) |
| 2158 | { |
| 2159 | struct weston_seat *seat = container_of(listener, struct weston_seat, |
| 2160 | sprite_destroy_listener); |
| 2161 | |
| 2162 | seat->sprite = NULL; |
| 2163 | } |
| 2164 | |
| 2165 | static void |
| 2166 | pointer_cursor_surface_configure(struct weston_surface *es, |
| 2167 | int32_t dx, int32_t dy) |
| 2168 | { |
| 2169 | struct weston_seat *seat = es->private; |
| 2170 | int x, y; |
| 2171 | |
| 2172 | assert(es == seat->sprite); |
| 2173 | |
| 2174 | seat->hotspot_x -= dx; |
| 2175 | seat->hotspot_y -= dy; |
| 2176 | |
| 2177 | x = wl_fixed_to_int(seat->seat.pointer->x) - seat->hotspot_x; |
| 2178 | y = wl_fixed_to_int(seat->seat.pointer->y) - seat->hotspot_y; |
| 2179 | |
| 2180 | weston_surface_configure(seat->sprite, x, y, |
| 2181 | es->buffer->width, es->buffer->height); |
| 2182 | |
Ander Conselvan de Oliveira | f1c00c0 | 2012-07-04 15:48:29 +0300 | [diff] [blame] | 2183 | empty_region(&es->input); |
| 2184 | |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2185 | if (!weston_surface_is_mapped(es)) { |
| 2186 | wl_list_insert(&es->compositor->cursor_layer.surface_list, |
| 2187 | &es->layer_link); |
| 2188 | weston_surface_assign_output(es); |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2189 | } |
| 2190 | } |
| 2191 | |
| 2192 | static void |
| 2193 | pointer_unmap_sprite(struct weston_seat *seat) |
| 2194 | { |
| 2195 | if (weston_surface_is_mapped(seat->sprite)) |
| 2196 | weston_surface_unmap(seat->sprite); |
| 2197 | |
| 2198 | wl_list_remove(&seat->sprite_destroy_listener.link); |
| 2199 | seat->sprite->configure = NULL; |
| 2200 | seat->sprite->private = NULL; |
| 2201 | seat->sprite = NULL; |
| 2202 | } |
| 2203 | |
| 2204 | static void |
| 2205 | pointer_set_cursor(struct wl_client *client, struct wl_resource *resource, |
| 2206 | uint32_t serial, struct wl_resource *surface_resource, |
| 2207 | int32_t x, int32_t y) |
Kristian Høgsberg | ab1862d | 2010-12-09 11:29:40 -0500 | [diff] [blame] | 2208 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2209 | struct weston_seat *seat = resource->data; |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2210 | struct weston_surface *surface = NULL; |
Kristian Høgsberg | ab1862d | 2010-12-09 11:29:40 -0500 | [diff] [blame] | 2211 | |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2212 | if (surface_resource) |
| 2213 | surface = container_of(surface_resource->data, |
| 2214 | struct weston_surface, surface); |
Kristian Høgsberg | 9629fe3 | 2012-03-26 15:56:39 -0400 | [diff] [blame] | 2215 | |
Kristian Høgsberg | 649e1ce | 2012-08-01 09:46:12 -0400 | [diff] [blame] | 2216 | if (seat->seat.pointer->focus == NULL) |
| 2217 | return; |
| 2218 | if (seat->seat.pointer->focus->resource.client != client) |
| 2219 | return; |
Kristian Høgsberg | 2e96d3c | 2012-08-01 09:39:11 -0400 | [diff] [blame] | 2220 | if (seat->seat.pointer->focus_serial - serial > UINT32_MAX / 2) |
Kristian Høgsberg | ab1862d | 2010-12-09 11:29:40 -0500 | [diff] [blame] | 2221 | return; |
Ander Conselvan de Oliveira | 1fbda0e | 2012-06-28 18:08:04 +0300 | [diff] [blame] | 2222 | |
| 2223 | if (surface && surface != seat->sprite) { |
Ander Conselvan de Oliveira | 1fbda0e | 2012-06-28 18:08:04 +0300 | [diff] [blame] | 2224 | if (surface->configure) { |
| 2225 | wl_resource_post_error(&surface->surface.resource, |
| 2226 | WL_DISPLAY_ERROR_INVALID_OBJECT, |
| 2227 | "surface->configure already " |
| 2228 | "set"); |
| 2229 | return; |
| 2230 | } |
Pekka Paalanen | f07cb5d | 2012-02-10 13:34:36 +0200 | [diff] [blame] | 2231 | } |
Kristian Høgsberg | cd9ac1d | 2011-12-15 09:14:34 -0500 | [diff] [blame] | 2232 | |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2233 | if (seat->sprite) |
| 2234 | pointer_unmap_sprite(seat); |
Ander Conselvan de Oliveira | e11683a | 2012-03-27 17:36:40 +0300 | [diff] [blame] | 2235 | |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2236 | if (!surface) |
| 2237 | return; |
| 2238 | |
| 2239 | wl_signal_add(&surface->surface.resource.destroy_signal, |
| 2240 | &seat->sprite_destroy_listener); |
| 2241 | |
| 2242 | surface->configure = pointer_cursor_surface_configure; |
| 2243 | surface->private = seat; |
| 2244 | empty_region(&surface->input); |
| 2245 | |
| 2246 | seat->sprite = surface; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2247 | seat->hotspot_x = x; |
| 2248 | seat->hotspot_y = y; |
Kristian Høgsberg | cd9ac1d | 2011-12-15 09:14:34 -0500 | [diff] [blame] | 2249 | |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2250 | weston_surface_set_position(surface, |
| 2251 | wl_fixed_to_int(seat->seat.pointer->x) - x, |
| 2252 | wl_fixed_to_int(seat->seat.pointer->y) - y); |
Kristian Høgsberg | ab1862d | 2010-12-09 11:29:40 -0500 | [diff] [blame] | 2253 | } |
| 2254 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2255 | static const struct wl_pointer_interface pointer_interface = { |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2256 | pointer_set_cursor |
Kristian Høgsberg | ab1862d | 2010-12-09 11:29:40 -0500 | [diff] [blame] | 2257 | }; |
| 2258 | |
Ander Conselvan de Oliveira | c5fb9a7 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2259 | static void |
Kristian Høgsberg | 27e3052 | 2012-04-11 23:18:23 -0400 | [diff] [blame] | 2260 | handle_drag_surface_destroy(struct wl_listener *listener, void *data) |
Ander Conselvan de Oliveira | c5fb9a7 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2261 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2262 | struct weston_seat *seat; |
Ander Conselvan de Oliveira | c5fb9a7 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2263 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2264 | seat = container_of(listener, struct weston_seat, |
| 2265 | drag_surface_destroy_listener); |
Ander Conselvan de Oliveira | c5fb9a7 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2266 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2267 | seat->drag_surface = NULL; |
Ander Conselvan de Oliveira | c5fb9a7 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2268 | } |
| 2269 | |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 2270 | static void unbind_resource(struct wl_resource *resource) |
Kristian Høgsberg | d2baf1f | 2011-10-11 22:20:37 -0400 | [diff] [blame] | 2271 | { |
| 2272 | wl_list_remove(&resource->link); |
| 2273 | free(resource); |
| 2274 | } |
| 2275 | |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 2276 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2277 | seat_get_pointer(struct wl_client *client, struct wl_resource *resource, |
| 2278 | uint32_t id) |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 2279 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2280 | struct weston_seat *seat = resource->data; |
| 2281 | struct wl_resource *cr; |
Kristian Høgsberg | 8e6d712 | 2011-08-29 16:04:39 -0400 | [diff] [blame] | 2282 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2283 | if (!seat->seat.pointer) |
| 2284 | return; |
| 2285 | |
| 2286 | cr = wl_client_add_object(client, &wl_pointer_interface, |
| 2287 | &pointer_interface, id, seat); |
| 2288 | wl_list_insert(&seat->seat.pointer->resource_list, &cr->link); |
Kristian Høgsberg | b93b6cf | 2012-05-16 22:32:40 -0400 | [diff] [blame] | 2289 | cr->destroy = unbind_resource; |
Daniel Stone | 17b13bd | 2012-05-30 16:31:39 +0100 | [diff] [blame] | 2290 | |
| 2291 | if (seat->seat.pointer->focus && |
| 2292 | seat->seat.pointer->focus->resource.client == client) { |
| 2293 | struct weston_surface *surface; |
| 2294 | wl_fixed_t sx, sy; |
| 2295 | |
| 2296 | surface = (struct weston_surface *) seat->seat.pointer->focus; |
| 2297 | weston_surface_from_global_fixed(surface, |
| 2298 | seat->seat.pointer->x, |
| 2299 | seat->seat.pointer->y, |
| 2300 | &sx, |
| 2301 | &sy); |
| 2302 | wl_pointer_set_focus(seat->seat.pointer, |
| 2303 | seat->seat.pointer->focus, |
| 2304 | sx, |
| 2305 | sy); |
| 2306 | } |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2307 | } |
| 2308 | |
| 2309 | static void |
| 2310 | seat_get_keyboard(struct wl_client *client, struct wl_resource *resource, |
| 2311 | uint32_t id) |
| 2312 | { |
| 2313 | struct weston_seat *seat = resource->data; |
| 2314 | struct wl_resource *cr; |
| 2315 | |
| 2316 | if (!seat->seat.keyboard) |
| 2317 | return; |
| 2318 | |
| 2319 | cr = wl_client_add_object(client, &wl_keyboard_interface, NULL, id, |
| 2320 | seat); |
| 2321 | wl_list_insert(&seat->seat.keyboard->resource_list, &cr->link); |
Kristian Høgsberg | b93b6cf | 2012-05-16 22:32:40 -0400 | [diff] [blame] | 2322 | cr->destroy = unbind_resource; |
Daniel Stone | 17b13bd | 2012-05-30 16:31:39 +0100 | [diff] [blame] | 2323 | |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2324 | wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1, |
| 2325 | seat->xkb_info.keymap_fd, |
| 2326 | seat->xkb_info.keymap_size); |
| 2327 | |
Daniel Stone | 17b13bd | 2012-05-30 16:31:39 +0100 | [diff] [blame] | 2328 | if (seat->seat.keyboard->focus && |
| 2329 | seat->seat.keyboard->focus->resource.client == client) { |
| 2330 | wl_keyboard_set_focus(seat->seat.keyboard, |
| 2331 | seat->seat.keyboard->focus); |
| 2332 | } |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2333 | } |
| 2334 | |
| 2335 | static void |
| 2336 | seat_get_touch(struct wl_client *client, struct wl_resource *resource, |
| 2337 | uint32_t id) |
| 2338 | { |
| 2339 | struct weston_seat *seat = resource->data; |
| 2340 | struct wl_resource *cr; |
| 2341 | |
| 2342 | if (!seat->seat.touch) |
| 2343 | return; |
| 2344 | |
| 2345 | cr = wl_client_add_object(client, &wl_touch_interface, NULL, id, seat); |
| 2346 | wl_list_insert(&seat->seat.touch->resource_list, &cr->link); |
Kristian Høgsberg | b93b6cf | 2012-05-16 22:32:40 -0400 | [diff] [blame] | 2347 | cr->destroy = unbind_resource; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2348 | } |
| 2349 | |
| 2350 | static const struct wl_seat_interface seat_interface = { |
| 2351 | seat_get_pointer, |
| 2352 | seat_get_keyboard, |
| 2353 | seat_get_touch, |
| 2354 | }; |
| 2355 | |
| 2356 | static void |
| 2357 | bind_seat(struct wl_client *client, void *data, uint32_t version, uint32_t id) |
| 2358 | { |
| 2359 | struct wl_seat *seat = data; |
| 2360 | struct wl_resource *resource; |
| 2361 | enum wl_seat_capability caps = 0; |
| 2362 | |
| 2363 | resource = wl_client_add_object(client, &wl_seat_interface, |
| 2364 | &seat_interface, id, data); |
| 2365 | wl_list_insert(&seat->base_resource_list, &resource->link); |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 2366 | resource->destroy = unbind_resource; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2367 | |
| 2368 | if (seat->pointer) |
| 2369 | caps |= WL_SEAT_CAPABILITY_POINTER; |
| 2370 | if (seat->keyboard) |
| 2371 | caps |= WL_SEAT_CAPABILITY_KEYBOARD; |
| 2372 | if (seat->touch) |
| 2373 | caps |= WL_SEAT_CAPABILITY_TOUCH; |
| 2374 | |
| 2375 | wl_seat_send_capabilities(resource, caps); |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 2376 | } |
| 2377 | |
Ander Conselvan de Oliveira | d6ea33d | 2012-03-27 17:36:39 +0300 | [diff] [blame] | 2378 | static void |
Kristian Høgsberg | 27e3052 | 2012-04-11 23:18:23 -0400 | [diff] [blame] | 2379 | device_handle_new_drag_icon(struct wl_listener *listener, void *data) |
Ander Conselvan de Oliveira | d6ea33d | 2012-03-27 17:36:39 +0300 | [diff] [blame] | 2380 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2381 | struct weston_seat *seat; |
Ander Conselvan de Oliveira | d6ea33d | 2012-03-27 17:36:39 +0300 | [diff] [blame] | 2382 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2383 | seat = container_of(listener, struct weston_seat, |
| 2384 | new_drag_icon_listener); |
Ander Conselvan de Oliveira | d6ea33d | 2012-03-27 17:36:39 +0300 | [diff] [blame] | 2385 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2386 | weston_seat_update_drag_surface(&seat->seat, 0, 0); |
Ander Conselvan de Oliveira | d6ea33d | 2012-03-27 17:36:39 +0300 | [diff] [blame] | 2387 | } |
| 2388 | |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2389 | static void weston_compositor_xkb_init(struct weston_compositor *ec, |
| 2390 | struct xkb_rule_names *names) |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 2391 | { |
Daniel Stone | e379da9 | 2012-05-30 16:32:04 +0100 | [diff] [blame] | 2392 | if (ec->xkb_context == NULL) { |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2393 | ec->xkb_context = xkb_context_new(0); |
| 2394 | if (ec->xkb_context == NULL) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 2395 | weston_log("failed to create XKB context\n"); |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2396 | exit(1); |
| 2397 | } |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 2398 | } |
| 2399 | |
| 2400 | if (names) |
Daniel Stone | e379da9 | 2012-05-30 16:32:04 +0100 | [diff] [blame] | 2401 | ec->xkb_names = *names; |
| 2402 | if (!ec->xkb_names.rules) |
| 2403 | ec->xkb_names.rules = strdup("evdev"); |
| 2404 | if (!ec->xkb_names.model) |
| 2405 | ec->xkb_names.model = strdup("pc105"); |
| 2406 | if (!ec->xkb_names.layout) |
| 2407 | ec->xkb_names.layout = strdup("us"); |
Daniel Stone | 9a9ee2c | 2012-05-30 16:32:03 +0100 | [diff] [blame] | 2408 | } |
| 2409 | |
Daniel Stone | e379da9 | 2012-05-30 16:32:04 +0100 | [diff] [blame] | 2410 | static void xkb_info_destroy(struct weston_xkb_info *xkb_info) |
| 2411 | { |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2412 | if (xkb_info->keymap) |
| 2413 | xkb_map_unref(xkb_info->keymap); |
| 2414 | |
| 2415 | if (xkb_info->keymap_area) |
| 2416 | munmap(xkb_info->keymap_area, xkb_info->keymap_size); |
| 2417 | if (xkb_info->keymap_fd >= 0) |
| 2418 | close(xkb_info->keymap_fd); |
Daniel Stone | e379da9 | 2012-05-30 16:32:04 +0100 | [diff] [blame] | 2419 | } |
| 2420 | |
Daniel Stone | 9a9ee2c | 2012-05-30 16:32:03 +0100 | [diff] [blame] | 2421 | static void weston_compositor_xkb_destroy(struct weston_compositor *ec) |
| 2422 | { |
Daniel Stone | e379da9 | 2012-05-30 16:32:04 +0100 | [diff] [blame] | 2423 | free((char *) ec->xkb_names.rules); |
| 2424 | free((char *) ec->xkb_names.model); |
| 2425 | free((char *) ec->xkb_names.layout); |
| 2426 | free((char *) ec->xkb_names.variant); |
| 2427 | free((char *) ec->xkb_names.options); |
Daniel Stone | 9a9ee2c | 2012-05-30 16:32:03 +0100 | [diff] [blame] | 2428 | |
Daniel Stone | e379da9 | 2012-05-30 16:32:04 +0100 | [diff] [blame] | 2429 | xkb_info_destroy(&ec->xkb_info); |
| 2430 | xkb_context_unref(ec->xkb_context); |
Daniel Stone | 9a9ee2c | 2012-05-30 16:32:03 +0100 | [diff] [blame] | 2431 | } |
| 2432 | |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2433 | static void |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2434 | weston_xkb_info_new_keymap(struct weston_xkb_info *xkb_info) |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2435 | { |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2436 | char *keymap_str; |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2437 | |
Daniel Stone | abb9dcd | 2012-06-22 13:21:33 +0100 | [diff] [blame] | 2438 | xkb_info->shift_mod = xkb_map_mod_get_index(xkb_info->keymap, |
| 2439 | XKB_MOD_NAME_SHIFT); |
| 2440 | xkb_info->caps_mod = xkb_map_mod_get_index(xkb_info->keymap, |
| 2441 | XKB_MOD_NAME_CAPS); |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2442 | xkb_info->ctrl_mod = xkb_map_mod_get_index(xkb_info->keymap, |
| 2443 | XKB_MOD_NAME_CTRL); |
| 2444 | xkb_info->alt_mod = xkb_map_mod_get_index(xkb_info->keymap, |
| 2445 | XKB_MOD_NAME_ALT); |
Daniel Stone | abb9dcd | 2012-06-22 13:21:33 +0100 | [diff] [blame] | 2446 | xkb_info->mod2_mod = xkb_map_mod_get_index(xkb_info->keymap, "Mod2"); |
| 2447 | xkb_info->mod3_mod = xkb_map_mod_get_index(xkb_info->keymap, "Mod3"); |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2448 | xkb_info->super_mod = xkb_map_mod_get_index(xkb_info->keymap, |
| 2449 | XKB_MOD_NAME_LOGO); |
Daniel Stone | abb9dcd | 2012-06-22 13:21:33 +0100 | [diff] [blame] | 2450 | xkb_info->mod5_mod = xkb_map_mod_get_index(xkb_info->keymap, "Mod5"); |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2451 | |
| 2452 | xkb_info->num_led = xkb_map_led_get_index(xkb_info->keymap, |
| 2453 | XKB_LED_NAME_NUM); |
| 2454 | xkb_info->caps_led = xkb_map_led_get_index(xkb_info->keymap, |
| 2455 | XKB_LED_NAME_CAPS); |
| 2456 | xkb_info->scroll_led = xkb_map_led_get_index(xkb_info->keymap, |
| 2457 | XKB_LED_NAME_SCROLL); |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2458 | |
| 2459 | keymap_str = xkb_map_get_as_string(xkb_info->keymap); |
| 2460 | if (keymap_str == NULL) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 2461 | weston_log("failed to get string version of keymap\n"); |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2462 | exit(EXIT_FAILURE); |
| 2463 | } |
| 2464 | xkb_info->keymap_size = strlen(keymap_str) + 1; |
| 2465 | |
Pekka Paalanen | 1da1b8f | 2012-06-06 16:59:43 +0300 | [diff] [blame] | 2466 | xkb_info->keymap_fd = os_create_anonymous_file(xkb_info->keymap_size); |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2467 | if (xkb_info->keymap_fd < 0) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 2468 | weston_log("creating a keymap file for %lu bytes failed: %m\n", |
Pekka Paalanen | 1da1b8f | 2012-06-06 16:59:43 +0300 | [diff] [blame] | 2469 | (unsigned long) xkb_info->keymap_size); |
| 2470 | goto err_keymap_str; |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2471 | } |
| 2472 | |
| 2473 | xkb_info->keymap_area = mmap(NULL, xkb_info->keymap_size, |
| 2474 | PROT_READ | PROT_WRITE, |
| 2475 | MAP_SHARED, xkb_info->keymap_fd, 0); |
| 2476 | if (xkb_info->keymap_area == MAP_FAILED) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 2477 | weston_log("failed to mmap() %lu bytes\n", |
Pekka Paalanen | 1da1b8f | 2012-06-06 16:59:43 +0300 | [diff] [blame] | 2478 | (unsigned long) xkb_info->keymap_size); |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2479 | goto err_dev_zero; |
| 2480 | } |
| 2481 | strcpy(xkb_info->keymap_area, keymap_str); |
| 2482 | free(keymap_str); |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2483 | |
| 2484 | return; |
| 2485 | |
| 2486 | err_dev_zero: |
| 2487 | close(xkb_info->keymap_fd); |
| 2488 | xkb_info->keymap_fd = -1; |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2489 | err_keymap_str: |
| 2490 | free(keymap_str); |
| 2491 | exit(EXIT_FAILURE); |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2492 | } |
| 2493 | |
| 2494 | static void |
Daniel Stone | 9a9ee2c | 2012-05-30 16:32:03 +0100 | [diff] [blame] | 2495 | weston_compositor_build_global_keymap(struct weston_compositor *ec) |
| 2496 | { |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2497 | if (ec->xkb_info.keymap != NULL) |
| 2498 | return; |
| 2499 | |
Daniel Stone | e379da9 | 2012-05-30 16:32:04 +0100 | [diff] [blame] | 2500 | ec->xkb_info.keymap = xkb_map_new_from_names(ec->xkb_context, |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2501 | &ec->xkb_names, |
| 2502 | 0); |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 2503 | if (ec->xkb_info.keymap == NULL) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 2504 | weston_log("failed to compile global XKB keymap\n"); |
| 2505 | weston_log(" tried rules %s, model %s, layout %s, variant %s, " |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2506 | "options %s", |
| 2507 | ec->xkb_names.rules, ec->xkb_names.model, |
| 2508 | ec->xkb_names.layout, ec->xkb_names.variant, |
| 2509 | ec->xkb_names.options); |
| 2510 | exit(1); |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 2511 | } |
| 2512 | |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2513 | weston_xkb_info_new_keymap(&ec->xkb_info); |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 2514 | } |
| 2515 | |
Daniel Stone | 9a9ee2c | 2012-05-30 16:32:03 +0100 | [diff] [blame] | 2516 | WL_EXPORT void |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2517 | weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap) |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 2518 | { |
Daniel Stone | 9a9ee2c | 2012-05-30 16:32:03 +0100 | [diff] [blame] | 2519 | if (seat->has_keyboard) |
| 2520 | return; |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 2521 | |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2522 | if (keymap != NULL) { |
| 2523 | seat->xkb_info.keymap = xkb_map_ref(keymap); |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 2524 | weston_xkb_info_new_keymap(&seat->xkb_info); |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 2525 | } |
| 2526 | else { |
| 2527 | weston_compositor_build_global_keymap(seat->compositor); |
| 2528 | seat->xkb_info = seat->compositor->xkb_info; |
| 2529 | seat->xkb_info.keymap = xkb_map_ref(seat->xkb_info.keymap); |
| 2530 | } |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 2531 | |
| 2532 | seat->xkb_state.state = xkb_state_new(seat->xkb_info.keymap); |
| 2533 | if (seat->xkb_state.state == NULL) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 2534 | weston_log("failed to initialise XKB state\n"); |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 2535 | exit(1); |
| 2536 | } |
| 2537 | |
Daniel Stone | 71c3877 | 2012-06-22 13:21:30 +0100 | [diff] [blame] | 2538 | seat->xkb_state.leds = 0; |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 2539 | |
Daniel Stone | 9a9ee2c | 2012-05-30 16:32:03 +0100 | [diff] [blame] | 2540 | wl_keyboard_init(&seat->keyboard); |
| 2541 | wl_seat_set_keyboard(&seat->seat, &seat->keyboard); |
| 2542 | |
| 2543 | seat->has_keyboard = 1; |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 2544 | } |
| 2545 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 2546 | WL_EXPORT void |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 2547 | weston_seat_init_pointer(struct weston_seat *seat) |
| 2548 | { |
| 2549 | if (seat->has_pointer) |
| 2550 | return; |
| 2551 | |
| 2552 | wl_pointer_init(&seat->pointer); |
| 2553 | wl_seat_set_pointer(&seat->seat, &seat->pointer); |
| 2554 | |
| 2555 | seat->has_pointer = 1; |
| 2556 | } |
| 2557 | |
| 2558 | WL_EXPORT void |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 2559 | weston_seat_init_touch(struct weston_seat *seat) |
| 2560 | { |
| 2561 | if (seat->has_touch) |
| 2562 | return; |
| 2563 | |
| 2564 | wl_touch_init(&seat->touch); |
| 2565 | wl_seat_set_touch(&seat->seat, &seat->touch); |
| 2566 | |
| 2567 | seat->has_touch = 1; |
| 2568 | } |
| 2569 | |
| 2570 | WL_EXPORT void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2571 | weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec) |
Kristian Høgsberg | cddc0ad | 2008-11-24 00:31:49 -0500 | [diff] [blame] | 2572 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2573 | wl_seat_init(&seat->seat); |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 2574 | seat->has_pointer = 0; |
| 2575 | seat->has_keyboard = 0; |
| 2576 | seat->has_touch = 0; |
Kristian Høgsberg | 02ef1c1 | 2010-12-06 21:35:19 -0500 | [diff] [blame] | 2577 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2578 | wl_display_add_global(ec->wl_display, &wl_seat_interface, seat, |
| 2579 | bind_seat); |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 2580 | |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2581 | seat->sprite = NULL; |
| 2582 | seat->sprite_destroy_listener.notify = pointer_handle_sprite_destroy; |
Kristian Høgsberg | 8244b44 | 2011-06-23 15:44:14 -0400 | [diff] [blame] | 2583 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2584 | seat->compositor = ec; |
| 2585 | seat->hotspot_x = 16; |
| 2586 | seat->hotspot_y = 16; |
| 2587 | seat->modifier_state = 0; |
| 2588 | seat->num_tp = 0; |
Kristian Høgsberg | 5ee1a60 | 2008-12-11 23:18:45 -0500 | [diff] [blame] | 2589 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2590 | seat->drag_surface_destroy_listener.notify = |
Kristian Høgsberg | 27e3052 | 2012-04-11 23:18:23 -0400 | [diff] [blame] | 2591 | handle_drag_surface_destroy; |
Ander Conselvan de Oliveira | c5fb9a7 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2592 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2593 | wl_list_insert(ec->seat_list.prev, &seat->link); |
Ander Conselvan de Oliveira | d6ea33d | 2012-03-27 17:36:39 +0300 | [diff] [blame] | 2594 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2595 | seat->new_drag_icon_listener.notify = device_handle_new_drag_icon; |
| 2596 | wl_signal_add(&seat->seat.drag_icon_signal, |
| 2597 | &seat->new_drag_icon_listener); |
Kristian Høgsberg | a7ceaff | 2012-06-03 10:20:13 -0400 | [diff] [blame] | 2598 | |
| 2599 | clipboard_create(seat); |
Kristian Høgsberg | 5ee1a60 | 2008-12-11 23:18:45 -0500 | [diff] [blame] | 2600 | } |
| 2601 | |
Pekka Paalanen | 07753fb | 2012-01-02 15:31:01 +0200 | [diff] [blame] | 2602 | WL_EXPORT void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2603 | weston_seat_release(struct weston_seat *seat) |
Pekka Paalanen | 07753fb | 2012-01-02 15:31:01 +0200 | [diff] [blame] | 2604 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2605 | wl_list_remove(&seat->link); |
Pekka Paalanen | 07753fb | 2012-01-02 15:31:01 +0200 | [diff] [blame] | 2606 | /* The global object is destroyed at wl_display_destroy() time. */ |
| 2607 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2608 | if (seat->sprite) |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2609 | pointer_unmap_sprite(seat); |
Pekka Paalanen | 07753fb | 2012-01-02 15:31:01 +0200 | [diff] [blame] | 2610 | |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 2611 | if (seat->xkb_state.state != NULL) |
| 2612 | xkb_state_unref(seat->xkb_state.state); |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 2613 | xkb_info_destroy(&seat->xkb_info); |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 2614 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2615 | wl_seat_release(&seat->seat); |
Pekka Paalanen | 07753fb | 2012-01-02 15:31:01 +0200 | [diff] [blame] | 2616 | } |
| 2617 | |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2618 | static void |
Ander Conselvan de Oliveira | 093bfa3 | 2012-03-27 17:36:41 +0300 | [diff] [blame] | 2619 | drag_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy) |
| 2620 | { |
| 2621 | weston_surface_configure(es, |
| 2622 | es->geometry.x + sx, es->geometry.y + sy, |
| 2623 | es->buffer->width, es->buffer->height); |
| 2624 | } |
| 2625 | |
| 2626 | static int |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2627 | device_setup_new_drag_surface(struct weston_seat *ws, |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2628 | struct weston_surface *surface) |
| 2629 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2630 | struct wl_seat *seat = &ws->seat; |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2631 | |
Ander Conselvan de Oliveira | 093bfa3 | 2012-03-27 17:36:41 +0300 | [diff] [blame] | 2632 | if (surface->configure) { |
| 2633 | wl_resource_post_error(&surface->surface.resource, |
| 2634 | WL_DISPLAY_ERROR_INVALID_OBJECT, |
| 2635 | "surface->configure already set"); |
| 2636 | return 0; |
| 2637 | } |
| 2638 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2639 | ws->drag_surface = surface; |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2640 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2641 | weston_surface_set_position(ws->drag_surface, |
| 2642 | wl_fixed_to_double(seat->pointer->x), |
| 2643 | wl_fixed_to_double(seat->pointer->y)); |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2644 | |
Ander Conselvan de Oliveira | 093bfa3 | 2012-03-27 17:36:41 +0300 | [diff] [blame] | 2645 | surface->configure = drag_surface_configure; |
| 2646 | |
Kristian Høgsberg | 27e3052 | 2012-04-11 23:18:23 -0400 | [diff] [blame] | 2647 | wl_signal_add(&surface->surface.resource.destroy_signal, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2648 | &ws->drag_surface_destroy_listener); |
Ander Conselvan de Oliveira | 093bfa3 | 2012-03-27 17:36:41 +0300 | [diff] [blame] | 2649 | |
| 2650 | return 1; |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2651 | } |
| 2652 | |
| 2653 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2654 | device_release_drag_surface(struct weston_seat *seat) |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2655 | { |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2656 | seat->drag_surface->configure = NULL; |
| 2657 | undef_region(&seat->drag_surface->input); |
| 2658 | wl_list_remove(&seat->drag_surface_destroy_listener.link); |
| 2659 | seat->drag_surface = NULL; |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2660 | } |
| 2661 | |
| 2662 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2663 | device_map_drag_surface(struct weston_seat *seat) |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2664 | { |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2665 | struct wl_list *list; |
| 2666 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2667 | if (weston_surface_is_mapped(seat->drag_surface) || |
| 2668 | !seat->drag_surface->buffer) |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2669 | return; |
| 2670 | |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 2671 | if (seat->sprite && weston_surface_is_mapped(seat->sprite)) |
| 2672 | list = &seat->sprite->layer_link; |
| 2673 | else |
| 2674 | list = &seat->compositor->cursor_layer.surface_list; |
| 2675 | |
| 2676 | wl_list_insert(list, &seat->drag_surface->layer_link); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2677 | weston_surface_assign_output(seat->drag_surface); |
| 2678 | empty_region(&seat->drag_surface->input); |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2679 | } |
| 2680 | |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2681 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2682 | weston_seat_update_drag_surface(struct wl_seat *seat, |
| 2683 | int dx, int dy) |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2684 | { |
| 2685 | int surface_changed = 0; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2686 | struct weston_seat *ws = (struct weston_seat *) seat; |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2687 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2688 | if (!ws->drag_surface && !seat->drag_surface) |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2689 | return; |
| 2690 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2691 | if (ws->drag_surface && seat->drag_surface && |
| 2692 | (&ws->drag_surface->surface.resource != |
| 2693 | &seat->drag_surface->resource)) |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2694 | /* between calls to this funcion we got a new drag_surface */ |
| 2695 | surface_changed = 1; |
| 2696 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2697 | if (!seat->drag_surface || surface_changed) { |
| 2698 | device_release_drag_surface(ws); |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2699 | if (!surface_changed) |
| 2700 | return; |
| 2701 | } |
| 2702 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2703 | if (!ws->drag_surface || surface_changed) { |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2704 | struct weston_surface *surface = (struct weston_surface *) |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2705 | seat->drag_surface; |
| 2706 | if (!device_setup_new_drag_surface(ws, surface)) |
Ander Conselvan de Oliveira | 093bfa3 | 2012-03-27 17:36:41 +0300 | [diff] [blame] | 2707 | return; |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2708 | } |
| 2709 | |
Ander Conselvan de Oliveira | 3e3bb32 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 2710 | /* the client may not have attached a buffer to the drag surface |
| 2711 | * when we setup it up, so check if map is needed on every update */ |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2712 | device_map_drag_surface(ws); |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2713 | |
Ander Conselvan de Oliveira | 90fbbd7 | 2012-02-28 17:59:33 +0200 | [diff] [blame] | 2714 | /* the client may have attached a buffer with a different size to |
| 2715 | * the drag surface, causing the input region to be reset */ |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2716 | if (region_is_undefined(&ws->drag_surface->input)) |
| 2717 | empty_region(&ws->drag_surface->input); |
Ander Conselvan de Oliveira | 90fbbd7 | 2012-02-28 17:59:33 +0200 | [diff] [blame] | 2718 | |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2719 | if (!dx && !dy) |
| 2720 | return; |
| 2721 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 2722 | weston_surface_set_position(ws->drag_surface, |
| 2723 | ws->drag_surface->geometry.x + wl_fixed_to_double(dx), |
| 2724 | ws->drag_surface->geometry.y + wl_fixed_to_double(dy)); |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2725 | } |
| 2726 | |
| 2727 | WL_EXPORT void |
| 2728 | weston_compositor_update_drag_surfaces(struct weston_compositor *compositor) |
| 2729 | { |
Daniel Stone | 4dab5db | 2012-05-30 16:31:53 +0100 | [diff] [blame] | 2730 | struct weston_seat *seat; |
| 2731 | |
| 2732 | wl_list_for_each(seat, &compositor->seat_list, link) |
| 2733 | weston_seat_update_drag_surface(&seat->seat, 0, 0); |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 2734 | } |
| 2735 | |
Kristian Høgsberg | 81ce09a | 2008-12-31 16:18:42 -0500 | [diff] [blame] | 2736 | static void |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 2737 | bind_output(struct wl_client *client, |
| 2738 | void *data, uint32_t version, uint32_t id) |
Kristian Høgsberg | bf9541f | 2008-11-25 12:10:09 -0500 | [diff] [blame] | 2739 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 2740 | struct weston_output *output = data; |
| 2741 | struct weston_mode *mode; |
Kristian Høgsberg | fd07fb7 | 2011-08-29 15:03:09 -0400 | [diff] [blame] | 2742 | struct wl_resource *resource; |
Kristian Høgsberg | 81ce09a | 2008-12-31 16:18:42 -0500 | [diff] [blame] | 2743 | |
Kristian Høgsberg | fd07fb7 | 2011-08-29 15:03:09 -0400 | [diff] [blame] | 2744 | resource = wl_client_add_object(client, |
| 2745 | &wl_output_interface, NULL, id, data); |
| 2746 | |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 2747 | wl_list_insert(&output->resource_list, &resource->link); |
| 2748 | resource->destroy = unbind_resource; |
| 2749 | |
Kristian Høgsberg | 0b5cd0c | 2012-03-04 21:57:37 -0500 | [diff] [blame] | 2750 | wl_output_send_geometry(resource, |
| 2751 | output->x, |
| 2752 | output->y, |
| 2753 | output->mm_width, |
| 2754 | output->mm_height, |
| 2755 | output->subpixel, |
Kristian Høgsberg | 0e69647 | 2012-07-22 15:49:57 -0400 | [diff] [blame] | 2756 | output->make, output->model, |
| 2757 | WL_OUTPUT_TRANSFORM_NORMAL); |
Kristian Høgsberg | 8f0ce05 | 2011-06-21 11:16:58 -0400 | [diff] [blame] | 2758 | |
| 2759 | wl_list_for_each (mode, &output->mode_list, link) { |
Kristian Høgsberg | 0b5cd0c | 2012-03-04 21:57:37 -0500 | [diff] [blame] | 2760 | wl_output_send_mode(resource, |
| 2761 | mode->flags, |
| 2762 | mode->width, |
| 2763 | mode->height, |
| 2764 | mode->refresh); |
Kristian Høgsberg | 8f0ce05 | 2011-06-21 11:16:58 -0400 | [diff] [blame] | 2765 | } |
Kristian Høgsberg | 81ce09a | 2008-12-31 16:18:42 -0500 | [diff] [blame] | 2766 | } |
| 2767 | |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2768 | static const char vertex_shader[] = |
| 2769 | "uniform mat4 proj;\n" |
Kristian Høgsberg | fa4e2a7 | 2011-02-13 13:44:55 -0500 | [diff] [blame] | 2770 | "attribute vec2 position;\n" |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2771 | "attribute vec2 texcoord;\n" |
| 2772 | "varying vec2 v_texcoord;\n" |
| 2773 | "void main()\n" |
| 2774 | "{\n" |
Kristian Høgsberg | fa4e2a7 | 2011-02-13 13:44:55 -0500 | [diff] [blame] | 2775 | " gl_Position = proj * vec4(position, 0.0, 1.0);\n" |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2776 | " v_texcoord = texcoord;\n" |
| 2777 | "}\n"; |
| 2778 | |
Gwenole Beauchesne | 6d03049 | 2012-04-20 11:15:51 +0200 | [diff] [blame] | 2779 | /* Declare common fragment shader uniforms */ |
| 2780 | #define FRAGMENT_SHADER_UNIFORMS \ |
| 2781 | "uniform float alpha;\n" \ |
| 2782 | "uniform float texwidth;\n" \ |
| 2783 | "uniform vec4 opaque;\n" |
| 2784 | |
| 2785 | /* Common fragment shader init code (check texture bounds) */ |
| 2786 | #define FRAGMENT_SHADER_INIT \ |
| 2787 | " if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n" \ |
| 2788 | " v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n" \ |
| 2789 | " discard;\n" |
| 2790 | |
| 2791 | #define FRAGMENT_SHADER_EXIT \ |
| 2792 | " if (opaque.x <= v_texcoord.x && v_texcoord.x < opaque.y &&\n" \ |
| 2793 | " opaque.z <= v_texcoord.y && v_texcoord.y < opaque.w)\n" \ |
| 2794 | " gl_FragColor.a = 1.0;\n" \ |
| 2795 | " gl_FragColor = alpha * gl_FragColor;\n" |
| 2796 | |
Gwenole Beauchesne | faf9185 | 2012-04-20 11:22:16 +0200 | [diff] [blame] | 2797 | #define FRAGMENT_CONVERT_YUV \ |
| 2798 | " gl_FragColor.r = y + 1.59602678 * v;\n" \ |
| 2799 | " gl_FragColor.g = y - 0.39176229 * u - 0.81296764 * v;\n" \ |
| 2800 | " gl_FragColor.b = y + 2.01723214 * u;\n" \ |
| 2801 | " gl_FragColor.a = 1.0;\n" |
| 2802 | |
Gwenole Beauchesne | 6d03049 | 2012-04-20 11:15:51 +0200 | [diff] [blame] | 2803 | static const char texture_fragment_shader_rgba[] = |
Kristian Høgsberg | dfce71d | 2010-12-07 20:19:10 -0500 | [diff] [blame] | 2804 | "precision mediump float;\n" |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2805 | "varying vec2 v_texcoord;\n" |
| 2806 | "uniform sampler2D tex;\n" |
Gwenole Beauchesne | 6d03049 | 2012-04-20 11:15:51 +0200 | [diff] [blame] | 2807 | FRAGMENT_SHADER_UNIFORMS |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2808 | "void main()\n" |
| 2809 | "{\n" |
Gwenole Beauchesne | 6d03049 | 2012-04-20 11:15:51 +0200 | [diff] [blame] | 2810 | FRAGMENT_SHADER_INIT |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2811 | " gl_FragColor = texture2D(tex, v_texcoord)\n;" |
Gwenole Beauchesne | 6d03049 | 2012-04-20 11:15:51 +0200 | [diff] [blame] | 2812 | FRAGMENT_SHADER_EXIT |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2813 | "}\n"; |
| 2814 | |
Gwenole Beauchesne | faf9185 | 2012-04-20 11:22:16 +0200 | [diff] [blame] | 2815 | static const char texture_fragment_shader_y_uv[] = |
| 2816 | "precision mediump float;\n" |
| 2817 | "uniform sampler2D tex;\n" |
| 2818 | "uniform sampler2D tex1;\n" |
| 2819 | "varying vec2 v_texcoord;\n" |
| 2820 | FRAGMENT_SHADER_UNIFORMS |
| 2821 | "void main() {\n" |
| 2822 | FRAGMENT_SHADER_INIT |
| 2823 | " float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n" |
| 2824 | " float u = texture2D(tex1, v_texcoord).r - 0.5;\n" |
| 2825 | " float v = texture2D(tex1, v_texcoord).g - 0.5;\n" |
| 2826 | FRAGMENT_CONVERT_YUV |
| 2827 | FRAGMENT_SHADER_EXIT |
| 2828 | "}\n"; |
| 2829 | |
| 2830 | static const char texture_fragment_shader_y_u_v[] = |
| 2831 | "precision mediump float;\n" |
| 2832 | "uniform sampler2D tex;\n" |
| 2833 | "uniform sampler2D tex1;\n" |
| 2834 | "uniform sampler2D tex2;\n" |
| 2835 | "varying vec2 v_texcoord;\n" |
| 2836 | FRAGMENT_SHADER_UNIFORMS |
| 2837 | "void main() {\n" |
| 2838 | FRAGMENT_SHADER_INIT |
| 2839 | " float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n" |
| 2840 | " float u = texture2D(tex1, v_texcoord).x - 0.5;\n" |
| 2841 | " float v = texture2D(tex2, v_texcoord).x - 0.5;\n" |
| 2842 | FRAGMENT_CONVERT_YUV |
| 2843 | FRAGMENT_SHADER_EXIT |
| 2844 | "}\n"; |
| 2845 | |
| 2846 | static const char texture_fragment_shader_y_xuxv[] = |
| 2847 | "precision mediump float;\n" |
| 2848 | "uniform sampler2D tex;\n" |
| 2849 | "uniform sampler2D tex1;\n" |
| 2850 | "varying vec2 v_texcoord;\n" |
| 2851 | FRAGMENT_SHADER_UNIFORMS |
| 2852 | "void main() {\n" |
| 2853 | FRAGMENT_SHADER_INIT |
| 2854 | " float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n" |
| 2855 | " float u = texture2D(tex1, v_texcoord).g - 0.5;\n" |
| 2856 | " float v = texture2D(tex1, v_texcoord).a - 0.5;\n" |
| 2857 | FRAGMENT_CONVERT_YUV |
| 2858 | FRAGMENT_SHADER_EXIT |
| 2859 | "}\n"; |
| 2860 | |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 2861 | static const char solid_fragment_shader[] = |
| 2862 | "precision mediump float;\n" |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 2863 | "uniform vec4 color;\n" |
Kristian Høgsberg | dbae80e | 2012-03-29 11:34:39 -0400 | [diff] [blame] | 2864 | "uniform float alpha;\n" |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 2865 | "void main()\n" |
| 2866 | "{\n" |
Kristian Høgsberg | dbae80e | 2012-03-29 11:34:39 -0400 | [diff] [blame] | 2867 | " gl_FragColor = alpha * color\n;" |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 2868 | "}\n"; |
| 2869 | |
Kristian Høgsberg | a946821 | 2010-06-14 21:03:11 -0400 | [diff] [blame] | 2870 | static int |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2871 | compile_shader(GLenum type, const char *source) |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2872 | { |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2873 | GLuint s; |
Kristian Høgsberg | 67a21bd | 2010-06-25 18:58:24 -0400 | [diff] [blame] | 2874 | char msg[512]; |
Kristian Høgsberg | 67a21bd | 2010-06-25 18:58:24 -0400 | [diff] [blame] | 2875 | GLint status; |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2876 | |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2877 | s = glCreateShader(type); |
| 2878 | glShaderSource(s, 1, &source, NULL); |
| 2879 | glCompileShader(s); |
| 2880 | glGetShaderiv(s, GL_COMPILE_STATUS, &status); |
Kristian Høgsberg | 67a21bd | 2010-06-25 18:58:24 -0400 | [diff] [blame] | 2881 | if (!status) { |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2882 | glGetShaderInfoLog(s, sizeof msg, NULL, msg); |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 2883 | weston_log("shader info: %s\n", msg); |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2884 | return GL_NONE; |
Kristian Høgsberg | 67a21bd | 2010-06-25 18:58:24 -0400 | [diff] [blame] | 2885 | } |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2886 | |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2887 | return s; |
| 2888 | } |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2889 | |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2890 | static int |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 2891 | weston_shader_init(struct weston_shader *shader, |
| 2892 | const char *vertex_source, const char *fragment_source) |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2893 | { |
| 2894 | char msg[512]; |
| 2895 | GLint status; |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2896 | |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2897 | shader->vertex_shader = |
| 2898 | compile_shader(GL_VERTEX_SHADER, vertex_source); |
| 2899 | shader->fragment_shader = |
| 2900 | compile_shader(GL_FRAGMENT_SHADER, fragment_source); |
| 2901 | |
| 2902 | shader->program = glCreateProgram(); |
| 2903 | glAttachShader(shader->program, shader->vertex_shader); |
| 2904 | glAttachShader(shader->program, shader->fragment_shader); |
| 2905 | glBindAttribLocation(shader->program, 0, "position"); |
| 2906 | glBindAttribLocation(shader->program, 1, "texcoord"); |
| 2907 | |
| 2908 | glLinkProgram(shader->program); |
| 2909 | glGetProgramiv(shader->program, GL_LINK_STATUS, &status); |
Kristian Høgsberg | 67a21bd | 2010-06-25 18:58:24 -0400 | [diff] [blame] | 2910 | if (!status) { |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2911 | glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg); |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 2912 | weston_log("link info: %s\n", msg); |
Kristian Høgsberg | 67a21bd | 2010-06-25 18:58:24 -0400 | [diff] [blame] | 2913 | return -1; |
| 2914 | } |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2915 | |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 2916 | shader->proj_uniform = glGetUniformLocation(shader->program, "proj"); |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 2917 | shader->tex_uniforms[0] = glGetUniformLocation(shader->program, "tex"); |
| 2918 | shader->tex_uniforms[1] = glGetUniformLocation(shader->program, "tex1"); |
| 2919 | shader->tex_uniforms[2] = glGetUniformLocation(shader->program, "tex2"); |
Kristian Høgsberg | 541e555 | 2011-12-14 09:24:11 -0500 | [diff] [blame] | 2920 | shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha"); |
Pekka Paalanen | f55f544 | 2012-02-02 16:49:05 +0200 | [diff] [blame] | 2921 | shader->color_uniform = glGetUniformLocation(shader->program, "color"); |
Scott Moreau | 9fb9824 | 2012-05-22 10:18:50 -0600 | [diff] [blame] | 2922 | shader->texwidth_uniform = glGetUniformLocation(shader->program, "texwidth"); |
| 2923 | shader->opaque_uniform = glGetUniformLocation(shader->program, "opaque"); |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2924 | |
Kristian Høgsberg | 67a21bd | 2010-06-25 18:58:24 -0400 | [diff] [blame] | 2925 | return 0; |
Kristian Høgsberg | 27803c6 | 2010-06-06 22:23:21 -0400 | [diff] [blame] | 2926 | } |
| 2927 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 2928 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 2929 | weston_output_destroy(struct weston_output *output) |
Kristian Høgsberg | 16eb675 | 2008-10-08 22:51:32 -0400 | [diff] [blame] | 2930 | { |
Benjamin Franzke | b687940 | 2012-04-10 18:28:54 +0200 | [diff] [blame] | 2931 | struct weston_compositor *c = output->compositor; |
| 2932 | |
Kristian Høgsberg | e75cb7f | 2011-06-21 15:27:41 -0400 | [diff] [blame] | 2933 | pixman_region32_fini(&output->region); |
Kristian Høgsberg | 8b72f60 | 2011-06-23 20:46:34 -0400 | [diff] [blame] | 2934 | pixman_region32_fini(&output->previous_damage); |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 2935 | output->compositor->output_id_pool &= ~(1 << output->id); |
Benjamin Franzke | b687940 | 2012-04-10 18:28:54 +0200 | [diff] [blame] | 2936 | |
| 2937 | wl_display_remove_global(c->wl_display, output->global); |
Benjamin Franzke | 9c26ff3 | 2011-03-15 15:08:41 +0100 | [diff] [blame] | 2938 | } |
| 2939 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 2940 | WL_EXPORT void |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 2941 | weston_output_update_matrix(struct weston_output *output) |
Benjamin Franzke | 9c26ff3 | 2011-03-15 15:08:41 +0100 | [diff] [blame] | 2942 | { |
Benjamin Franzke | 1b765ff | 2011-02-18 16:51:37 +0100 | [diff] [blame] | 2943 | int flip; |
Scott Moreau | 850ca42 | 2012-05-21 15:21:25 -0600 | [diff] [blame] | 2944 | float magnification; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 2945 | struct weston_matrix camera; |
| 2946 | struct weston_matrix modelview; |
Kristian Høgsberg | 31bd6c7 | 2011-02-13 13:00:51 -0500 | [diff] [blame] | 2947 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 2948 | weston_matrix_init(&output->matrix); |
| 2949 | weston_matrix_translate(&output->matrix, |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 2950 | -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0), |
| 2951 | -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0); |
Benjamin Franzke | 1b765ff | 2011-02-18 16:51:37 +0100 | [diff] [blame] | 2952 | |
Benjamin Franzke | 9c26ff3 | 2011-03-15 15:08:41 +0100 | [diff] [blame] | 2953 | flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 2954 | weston_matrix_scale(&output->matrix, |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 2955 | 2.0 / (output->current->width + output->border.left + output->border.right), |
| 2956 | flip * 2.0 / (output->current->height + output->border.top + output->border.bottom), 1); |
Scott Moreau | 850ca42 | 2012-05-21 15:21:25 -0600 | [diff] [blame] | 2957 | |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 2958 | if (output->zoom.active) { |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 2959 | magnification = 1 / (1 - output->zoom.spring_z.current); |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 2960 | weston_matrix_init(&camera); |
| 2961 | weston_matrix_init(&modelview); |
Scott Moreau | 8dacaab | 2012-06-17 18:10:58 -0600 | [diff] [blame] | 2962 | weston_output_update_zoom(output, output->zoom.type); |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 2963 | weston_matrix_translate(&camera, output->zoom.trans_x, |
| 2964 | flip * output->zoom.trans_y, 0); |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 2965 | weston_matrix_invert(&modelview, &camera); |
Scott Moreau | 850ca42 | 2012-05-21 15:21:25 -0600 | [diff] [blame] | 2966 | weston_matrix_scale(&modelview, magnification, magnification, 1.0); |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 2967 | weston_matrix_multiply(&output->matrix, &modelview); |
| 2968 | } |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 2969 | |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 2970 | output->dirty = 0; |
| 2971 | } |
| 2972 | |
| 2973 | WL_EXPORT void |
| 2974 | weston_output_move(struct weston_output *output, int x, int y) |
| 2975 | { |
| 2976 | output->x = x; |
| 2977 | output->y = y; |
| 2978 | |
| 2979 | pixman_region32_init(&output->previous_damage); |
| 2980 | pixman_region32_init_rect(&output->region, x, y, |
| 2981 | output->current->width, |
| 2982 | output->current->height); |
Benjamin Franzke | 9c26ff3 | 2011-03-15 15:08:41 +0100 | [diff] [blame] | 2983 | } |
| 2984 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 2985 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 2986 | weston_output_init(struct weston_output *output, struct weston_compositor *c, |
| 2987 | int x, int y, int width, int height, uint32_t flags) |
Benjamin Franzke | 9c26ff3 | 2011-03-15 15:08:41 +0100 | [diff] [blame] | 2988 | { |
| 2989 | output->compositor = c; |
| 2990 | output->x = x; |
| 2991 | output->y = y; |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 2992 | output->border.top = 0; |
| 2993 | output->border.bottom = 0; |
| 2994 | output->border.left = 0; |
| 2995 | output->border.right = 0; |
Kristian Høgsberg | 8f0ce05 | 2011-06-21 11:16:58 -0400 | [diff] [blame] | 2996 | output->mm_width = width; |
| 2997 | output->mm_height = height; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 2998 | output->dirty = 1; |
| 2999 | |
Scott Moreau | 429490d | 2012-06-17 18:10:59 -0600 | [diff] [blame] | 3000 | weston_output_init_zoom(output); |
Benjamin Franzke | 9c26ff3 | 2011-03-15 15:08:41 +0100 | [diff] [blame] | 3001 | |
Benjamin Franzke | 9c26ff3 | 2011-03-15 15:08:41 +0100 | [diff] [blame] | 3002 | output->flags = flags; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 3003 | weston_output_move(output, x, y); |
Benjamin Franzke | 78db848 | 2012-04-10 18:35:33 +0200 | [diff] [blame] | 3004 | weston_output_damage(output); |
Benjamin Franzke | 9c26ff3 | 2011-03-15 15:08:41 +0100 | [diff] [blame] | 3005 | |
Kristian Høgsberg | 5fb70bf | 2012-05-24 12:29:46 -0400 | [diff] [blame] | 3006 | wl_signal_init(&output->frame_signal); |
Scott Moreau | 9d1b112 | 2012-06-08 19:40:53 -0600 | [diff] [blame] | 3007 | wl_list_init(&output->animation_list); |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 3008 | wl_list_init(&output->resource_list); |
Benjamin Franzke | 0628626 | 2011-05-06 19:12:33 +0200 | [diff] [blame] | 3009 | |
Casey Dahlin | 58ba137 | 2012-04-19 22:50:08 -0400 | [diff] [blame] | 3010 | output->id = ffs(~output->compositor->output_id_pool) - 1; |
| 3011 | output->compositor->output_id_pool |= 1 << output->id; |
| 3012 | |
Benjamin Franzke | b687940 | 2012-04-10 18:28:54 +0200 | [diff] [blame] | 3013 | output->global = |
| 3014 | wl_display_add_global(c->wl_display, &wl_output_interface, |
| 3015 | output, bind_output); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 3016 | } |
| 3017 | |
Benjamin Franzke | 315b3dc | 2011-03-08 11:32:57 +0100 | [diff] [blame] | 3018 | static void |
Kristian Høgsberg | a887312 | 2011-11-23 10:39:34 -0500 | [diff] [blame] | 3019 | compositor_bind(struct wl_client *client, |
| 3020 | void *data, uint32_t version, uint32_t id) |
| 3021 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 3022 | struct weston_compositor *compositor = data; |
Kristian Høgsberg | a887312 | 2011-11-23 10:39:34 -0500 | [diff] [blame] | 3023 | |
| 3024 | wl_client_add_object(client, &wl_compositor_interface, |
| 3025 | &compositor_interface, id, compositor); |
| 3026 | } |
| 3027 | |
Kristian Høgsberg | fc9c5e0 | 2012-06-08 16:45:33 -0400 | [diff] [blame] | 3028 | static void |
Martin Minarik | f12c287 | 2012-06-11 00:57:39 +0200 | [diff] [blame] | 3029 | log_uname(void) |
| 3030 | { |
| 3031 | struct utsname usys; |
| 3032 | |
| 3033 | uname(&usys); |
| 3034 | |
| 3035 | weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release, |
| 3036 | usys.version, usys.machine); |
| 3037 | } |
| 3038 | |
| 3039 | static void |
Kristian Høgsberg | fc9c5e0 | 2012-06-08 16:45:33 -0400 | [diff] [blame] | 3040 | log_extensions(const char *name, const char *extensions) |
| 3041 | { |
| 3042 | const char *p, *end; |
| 3043 | int l; |
| 3044 | |
| 3045 | l = weston_log("%s:", name); |
| 3046 | p = extensions; |
| 3047 | while (*p) { |
| 3048 | end = strchrnul(p, ' '); |
| 3049 | if (l + (end - p) > 78) |
Pekka Paalanen | 4e4167d | 2012-06-11 14:06:05 +0300 | [diff] [blame] | 3050 | l = weston_log_continue("\n" STAMP_SPACE "%.*s", |
| 3051 | end - p, p); |
Kristian Høgsberg | fc9c5e0 | 2012-06-08 16:45:33 -0400 | [diff] [blame] | 3052 | else |
| 3053 | l += weston_log_continue(" %.*s", end - p, p); |
| 3054 | for (p = end; isspace(*p); p++) |
| 3055 | ; |
| 3056 | } |
| 3057 | weston_log_continue("\n"); |
| 3058 | } |
| 3059 | |
Pekka Paalanen | 4e4167d | 2012-06-11 14:06:05 +0300 | [diff] [blame] | 3060 | static void |
| 3061 | log_egl_gl_info(EGLDisplay egldpy) |
| 3062 | { |
| 3063 | const char *str; |
| 3064 | |
| 3065 | str = eglQueryString(egldpy, EGL_VERSION); |
| 3066 | weston_log("EGL version: %s\n", str ? str : "(null)"); |
| 3067 | |
| 3068 | str = eglQueryString(egldpy, EGL_VENDOR); |
| 3069 | weston_log("EGL vendor: %s\n", str ? str : "(null)"); |
| 3070 | |
| 3071 | str = eglQueryString(egldpy, EGL_CLIENT_APIS); |
| 3072 | weston_log("EGL client APIs: %s\n", str ? str : "(null)"); |
| 3073 | |
| 3074 | str = eglQueryString(egldpy, EGL_EXTENSIONS); |
| 3075 | log_extensions("EGL extensions", str ? str : "(null)"); |
| 3076 | |
| 3077 | str = (char *)glGetString(GL_VERSION); |
| 3078 | weston_log("GL version: %s\n", str ? str : "(null)"); |
| 3079 | |
| 3080 | str = (char *)glGetString(GL_SHADING_LANGUAGE_VERSION); |
| 3081 | weston_log("GLSL version: %s\n", str ? str : "(null)"); |
| 3082 | |
| 3083 | str = (char *)glGetString(GL_VENDOR); |
| 3084 | weston_log("GL vendor: %s\n", str ? str : "(null)"); |
| 3085 | |
| 3086 | str = (char *)glGetString(GL_RENDERER); |
| 3087 | weston_log("GL renderer: %s\n", str ? str : "(null)"); |
| 3088 | |
| 3089 | str = (char *)glGetString(GL_EXTENSIONS); |
| 3090 | log_extensions("GL extensions", str ? str : "(null)"); |
| 3091 | } |
| 3092 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3093 | WL_EXPORT int |
Daniel Stone | baf4359 | 2012-06-01 11:11:10 -0400 | [diff] [blame] | 3094 | weston_compositor_init(struct weston_compositor *ec, |
| 3095 | struct wl_display *display, |
| 3096 | int argc, |
Daniel Stone | c1be8e5 | 2012-06-01 11:14:02 -0400 | [diff] [blame] | 3097 | char *argv[], |
| 3098 | const char *config_file) |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 3099 | { |
Kristian Høgsberg | fbdbbdc | 2008-11-28 17:06:06 -0500 | [diff] [blame] | 3100 | struct wl_event_loop *loop; |
Daniel Stone | e2ef43a | 2012-06-01 12:14:05 +0100 | [diff] [blame] | 3101 | struct xkb_rule_names xkb_names; |
| 3102 | const struct config_key keyboard_config_keys[] = { |
| 3103 | { "keymap_rules", CONFIG_KEY_STRING, &xkb_names.rules }, |
| 3104 | { "keymap_model", CONFIG_KEY_STRING, &xkb_names.model }, |
| 3105 | { "keymap_layout", CONFIG_KEY_STRING, &xkb_names.layout }, |
| 3106 | { "keymap_variant", CONFIG_KEY_STRING, &xkb_names.variant }, |
| 3107 | { "keymap_options", CONFIG_KEY_STRING, &xkb_names.options }, |
| 3108 | }; |
| 3109 | const struct config_section cs[] = { |
| 3110 | { "keyboard", |
| 3111 | keyboard_config_keys, ARRAY_LENGTH(keyboard_config_keys) }, |
| 3112 | }; |
| 3113 | |
| 3114 | memset(&xkb_names, 0, sizeof(xkb_names)); |
| 3115 | parse_config_file(config_file, cs, ARRAY_LENGTH(cs), ec); |
Kristian Høgsberg | 16eb675 | 2008-10-08 22:51:32 -0400 | [diff] [blame] | 3116 | |
Kristian Høgsberg | f921289 | 2008-10-11 18:40:23 -0400 | [diff] [blame] | 3117 | ec->wl_display = display; |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 3118 | wl_signal_init(&ec->destroy_signal); |
| 3119 | wl_signal_init(&ec->activate_signal); |
| 3120 | wl_signal_init(&ec->lock_signal); |
| 3121 | wl_signal_init(&ec->unlock_signal); |
Jan Arne Petersen | 42feced | 2012-06-21 21:52:17 +0200 | [diff] [blame] | 3122 | wl_signal_init(&ec->show_input_panel_signal); |
| 3123 | wl_signal_init(&ec->hide_input_panel_signal); |
Benjamin Franzke | bfeda13 | 2012-01-30 14:04:04 +0100 | [diff] [blame] | 3124 | ec->launcher_sock = weston_environment_get_fd("WESTON_LAUNCHER_SOCK"); |
Kristian Høgsberg | 16eb675 | 2008-10-08 22:51:32 -0400 | [diff] [blame] | 3125 | |
Casey Dahlin | 58ba137 | 2012-04-19 22:50:08 -0400 | [diff] [blame] | 3126 | ec->output_id_pool = 0; |
| 3127 | |
Kristian Høgsberg | a887312 | 2011-11-23 10:39:34 -0500 | [diff] [blame] | 3128 | if (!wl_display_add_global(display, &wl_compositor_interface, |
| 3129 | ec, compositor_bind)) |
| 3130 | return -1; |
Kristian Høgsberg | ee02ca6 | 2008-12-21 23:37:12 -0500 | [diff] [blame] | 3131 | |
Daniel Stone | 725c2c3 | 2012-06-22 14:04:36 +0100 | [diff] [blame] | 3132 | wl_list_init(&ec->surface_list); |
| 3133 | wl_list_init(&ec->layer_list); |
| 3134 | wl_list_init(&ec->seat_list); |
| 3135 | wl_list_init(&ec->output_list); |
| 3136 | wl_list_init(&ec->key_binding_list); |
| 3137 | wl_list_init(&ec->button_binding_list); |
| 3138 | wl_list_init(&ec->axis_binding_list); |
| 3139 | wl_list_init(&ec->fade.animation.link); |
| 3140 | |
| 3141 | weston_compositor_xkb_init(ec, &xkb_names); |
| 3142 | |
| 3143 | ec->ping_handler = NULL; |
| 3144 | |
| 3145 | screenshooter_create(ec); |
| 3146 | text_cursor_position_notifier_create(ec); |
| 3147 | input_method_create(ec); |
| 3148 | |
| 3149 | wl_data_device_manager_init(ec->wl_display); |
| 3150 | |
Kristian Høgsberg | 9629fe3 | 2012-03-26 15:56:39 -0400 | [diff] [blame] | 3151 | wl_display_init_shm(display); |
Kristian Høgsberg | b5819dc | 2011-04-25 15:08:20 -0400 | [diff] [blame] | 3152 | |
Daniel Stone | 725c2c3 | 2012-06-22 14:04:36 +0100 | [diff] [blame] | 3153 | loop = wl_display_get_event_loop(ec->wl_display); |
| 3154 | ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec); |
| 3155 | wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000); |
| 3156 | |
| 3157 | ec->input_loop = wl_event_loop_create(); |
| 3158 | |
| 3159 | return 0; |
| 3160 | } |
| 3161 | |
| 3162 | WL_EXPORT int |
| 3163 | weston_compositor_init_gl(struct weston_compositor *ec) |
| 3164 | { |
| 3165 | const char *extensions; |
| 3166 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 3167 | log_egl_gl_info(ec->egl_display); |
Kristian Høgsberg | fc9c5e0 | 2012-06-08 16:45:33 -0400 | [diff] [blame] | 3168 | |
Kristian Høgsberg | b5819dc | 2011-04-25 15:08:20 -0400 | [diff] [blame] | 3169 | ec->image_target_texture_2d = |
| 3170 | (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES"); |
| 3171 | ec->image_target_renderbuffer_storage = (void *) |
| 3172 | eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES"); |
| 3173 | ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR"); |
| 3174 | ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR"); |
| 3175 | ec->bind_display = |
| 3176 | (void *) eglGetProcAddress("eglBindWaylandDisplayWL"); |
| 3177 | ec->unbind_display = |
| 3178 | (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL"); |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 3179 | ec->query_buffer = |
| 3180 | (void *) eglGetProcAddress("eglQueryWaylandBufferWL"); |
Kristian Høgsberg | b5819dc | 2011-04-25 15:08:20 -0400 | [diff] [blame] | 3181 | |
| 3182 | extensions = (const char *) glGetString(GL_EXTENSIONS); |
Pekka Paalanen | 299e58d | 2012-04-12 14:45:35 +0300 | [diff] [blame] | 3183 | if (!extensions) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 3184 | weston_log("Retrieving GL extension string failed.\n"); |
Pekka Paalanen | 299e58d | 2012-04-12 14:45:35 +0300 | [diff] [blame] | 3185 | return -1; |
| 3186 | } |
| 3187 | |
Kristian Høgsberg | b5819dc | 2011-04-25 15:08:20 -0400 | [diff] [blame] | 3188 | if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 3189 | weston_log("GL_EXT_texture_format_BGRA8888 not available\n"); |
Kristian Høgsberg | b5819dc | 2011-04-25 15:08:20 -0400 | [diff] [blame] | 3190 | return -1; |
| 3191 | } |
| 3192 | |
Pekka Paalanen | a1d57db | 2012-04-17 15:02:08 +0300 | [diff] [blame] | 3193 | if (strstr(extensions, "GL_EXT_read_format_bgra")) |
| 3194 | ec->read_format = GL_BGRA_EXT; |
| 3195 | else |
| 3196 | ec->read_format = GL_RGBA; |
Kristian Høgsberg | f9247dd | 2012-03-27 15:25:46 -0400 | [diff] [blame] | 3197 | |
Pekka Paalanen | 52bfbaa | 2012-04-11 16:19:37 +0300 | [diff] [blame] | 3198 | if (strstr(extensions, "GL_EXT_unpack_subimage")) |
| 3199 | ec->has_unpack_subimage = 1; |
Kristian Høgsberg | fb6de22 | 2012-03-27 17:10:13 -0400 | [diff] [blame] | 3200 | |
Kristian Høgsberg | b5819dc | 2011-04-25 15:08:20 -0400 | [diff] [blame] | 3201 | extensions = |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 3202 | (const char *) eglQueryString(ec->egl_display, EGL_EXTENSIONS); |
Pekka Paalanen | 299e58d | 2012-04-12 14:45:35 +0300 | [diff] [blame] | 3203 | if (!extensions) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 3204 | weston_log("Retrieving EGL extension string failed.\n"); |
Pekka Paalanen | 299e58d | 2012-04-12 14:45:35 +0300 | [diff] [blame] | 3205 | return -1; |
| 3206 | } |
| 3207 | |
Kristian Høgsberg | b5819dc | 2011-04-25 15:08:20 -0400 | [diff] [blame] | 3208 | if (strstr(extensions, "EGL_WL_bind_wayland_display")) |
| 3209 | ec->has_bind_display = 1; |
| 3210 | if (ec->has_bind_display) |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 3211 | ec->bind_display(ec->egl_display, ec->wl_display); |
Kristian Høgsberg | 3d5bae0 | 2010-10-06 21:17:40 -0400 | [diff] [blame] | 3212 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 3213 | weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0); |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 3214 | ec->fade.animation.frame = fade_frame; |
Kristian Høgsberg | 3555d09 | 2011-04-11 13:58:13 -0400 | [diff] [blame] | 3215 | |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 3216 | weston_layer_init(&ec->fade_layer, &ec->layer_list); |
| 3217 | weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link); |
| 3218 | |
Kristian Høgsberg | fc783d4 | 2010-06-11 12:56:24 -0400 | [diff] [blame] | 3219 | glActiveTexture(GL_TEXTURE0); |
Kristian Høgsberg | 7ffc448 | 2011-04-22 14:23:51 -0400 | [diff] [blame] | 3220 | |
Gwenole Beauchesne | 6d03049 | 2012-04-20 11:15:51 +0200 | [diff] [blame] | 3221 | if (weston_shader_init(&ec->texture_shader_rgba, |
| 3222 | vertex_shader, texture_fragment_shader_rgba) < 0) |
Kristian Høgsberg | a946821 | 2010-06-14 21:03:11 -0400 | [diff] [blame] | 3223 | return -1; |
Gwenole Beauchesne | faf9185 | 2012-04-20 11:22:16 +0200 | [diff] [blame] | 3224 | if (weston_shader_init(&ec->texture_shader_y_uv, |
| 3225 | vertex_shader, texture_fragment_shader_y_uv) < 0) |
| 3226 | return -1; |
| 3227 | if (weston_shader_init(&ec->texture_shader_y_u_v, |
| 3228 | vertex_shader, texture_fragment_shader_y_u_v) < 0) |
| 3229 | return -1; |
| 3230 | if (weston_shader_init(&ec->texture_shader_y_xuxv, |
| 3231 | vertex_shader, texture_fragment_shader_y_xuxv) < 0) |
| 3232 | return -1; |
Pekka Paalanen | f55f544 | 2012-02-02 16:49:05 +0200 | [diff] [blame] | 3233 | if (weston_shader_init(&ec->solid_shader, |
| 3234 | vertex_shader, solid_fragment_shader) < 0) |
Kristian Høgsberg | cce1aec | 2011-04-22 15:38:14 -0400 | [diff] [blame] | 3235 | return -1; |
Kristian Høgsberg | 8d7ca6b | 2008-11-09 00:22:51 -0500 | [diff] [blame] | 3236 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 3237 | weston_compositor_schedule_repaint(ec); |
Kristian Høgsberg | ef7a9ca | 2008-10-11 21:21:39 -0400 | [diff] [blame] | 3238 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 3239 | return 0; |
Kristian Høgsberg | 122912c | 2008-12-05 11:13:50 -0500 | [diff] [blame] | 3240 | } |
| 3241 | |
Benjamin Franzke | b826302 | 2011-08-30 11:32:47 +0200 | [diff] [blame] | 3242 | WL_EXPORT void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 3243 | weston_compositor_shutdown(struct weston_compositor *ec) |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 3244 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 3245 | struct weston_output *output, *next; |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 3246 | |
Pekka Paalanen | d1591ae | 2012-01-02 16:06:56 +0200 | [diff] [blame] | 3247 | wl_event_source_remove(ec->idle_source); |
Jonas Ådahl | c97af92 | 2012-03-28 22:36:09 +0200 | [diff] [blame] | 3248 | if (ec->input_loop_source) |
| 3249 | wl_event_source_remove(ec->input_loop_source); |
Pekka Paalanen | d1591ae | 2012-01-02 16:06:56 +0200 | [diff] [blame] | 3250 | |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 3251 | /* Destroy all outputs associated with this compositor */ |
Tiago Vignatti | b303a1d | 2011-12-18 22:27:40 +0200 | [diff] [blame] | 3252 | wl_list_for_each_safe(output, next, &ec->output_list, link) |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 3253 | output->destroy(output); |
Pekka Paalanen | 4738f3b | 2012-01-02 15:47:07 +0200 | [diff] [blame] | 3254 | |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 3255 | weston_binding_list_destroy_all(&ec->key_binding_list); |
| 3256 | weston_binding_list_destroy_all(&ec->button_binding_list); |
| 3257 | weston_binding_list_destroy_all(&ec->axis_binding_list); |
Pekka Paalanen | d1591ae | 2012-01-02 16:06:56 +0200 | [diff] [blame] | 3258 | |
Pekka Paalanen | d1591ae | 2012-01-02 16:06:56 +0200 | [diff] [blame] | 3259 | wl_array_release(&ec->vertices); |
| 3260 | wl_array_release(&ec->indices); |
Jonas Ådahl | c97af92 | 2012-03-28 22:36:09 +0200 | [diff] [blame] | 3261 | |
| 3262 | wl_event_loop_destroy(ec->input_loop); |
Daniel Stone | 816c98e | 2012-07-23 19:54:58 +0100 | [diff] [blame] | 3263 | |
| 3264 | pixman_region32_fini(&ec->damage); |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 3265 | } |
| 3266 | |
Kristian Høgsberg | b186847 | 2011-04-22 12:27:57 -0400 | [diff] [blame] | 3267 | static int on_term_signal(int signal_number, void *data) |
Kristian Høgsberg | 50dc698 | 2010-12-01 16:43:56 -0500 | [diff] [blame] | 3268 | { |
Kristian Høgsberg | 6bded3f | 2011-08-12 14:55:07 -0400 | [diff] [blame] | 3269 | struct wl_display *display = data; |
Kristian Høgsberg | 50dc698 | 2010-12-01 16:43:56 -0500 | [diff] [blame] | 3270 | |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 3271 | weston_log("caught signal %d\n", signal_number); |
Kristian Høgsberg | 6bded3f | 2011-08-12 14:55:07 -0400 | [diff] [blame] | 3272 | wl_display_terminate(display); |
Kristian Høgsberg | b186847 | 2011-04-22 12:27:57 -0400 | [diff] [blame] | 3273 | |
| 3274 | return 1; |
Kristian Høgsberg | 50dc698 | 2010-12-01 16:43:56 -0500 | [diff] [blame] | 3275 | } |
| 3276 | |
Kristian Høgsberg | 0690da6 | 2012-01-16 11:53:54 -0500 | [diff] [blame] | 3277 | static void |
| 3278 | on_segv_signal(int s, siginfo_t *siginfo, void *context) |
| 3279 | { |
| 3280 | void *buffer[32]; |
| 3281 | int i, count; |
| 3282 | Dl_info info; |
| 3283 | |
Kristian Høgsberg | 7b884bc | 2012-07-31 14:32:01 -0400 | [diff] [blame] | 3284 | /* This SIGSEGV handler will do a best-effort backtrace, and |
| 3285 | * then call the backend restore function, which will switch |
| 3286 | * back to the vt we launched from or ungrab X etc and then |
| 3287 | * raise SIGTRAP. If we run weston under gdb from X or a |
| 3288 | * different vt, and tell gdb "handle SIGSEGV nostop", this |
| 3289 | * will allow weston to switch back to gdb on crash and then |
| 3290 | * gdb will catch the crash with SIGTRAP. */ |
| 3291 | |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 3292 | weston_log("caught segv\n"); |
Kristian Høgsberg | 0690da6 | 2012-01-16 11:53:54 -0500 | [diff] [blame] | 3293 | |
| 3294 | count = backtrace(buffer, ARRAY_LENGTH(buffer)); |
| 3295 | for (i = 0; i < count; i++) { |
| 3296 | dladdr(buffer[i], &info); |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 3297 | weston_log(" [%016lx] %s (%s)\n", |
Kristian Høgsberg | 0690da6 | 2012-01-16 11:53:54 -0500 | [diff] [blame] | 3298 | (long) buffer[i], |
| 3299 | info.dli_sname ? info.dli_sname : "--", |
| 3300 | info.dli_fname); |
| 3301 | } |
| 3302 | |
Kristian Høgsberg | 7b884bc | 2012-07-31 14:32:01 -0400 | [diff] [blame] | 3303 | segv_compositor->restore(segv_compositor); |
| 3304 | |
| 3305 | raise(SIGTRAP); |
Kristian Høgsberg | 0690da6 | 2012-01-16 11:53:54 -0500 | [diff] [blame] | 3306 | } |
| 3307 | |
| 3308 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3309 | static void * |
| 3310 | load_module(const char *name, const char *entrypoint, void **handle) |
| 3311 | { |
| 3312 | char path[PATH_MAX]; |
| 3313 | void *module, *init; |
| 3314 | |
| 3315 | if (name[0] != '/') |
Chad Versace | bf38190 | 2012-05-23 23:42:15 -0700 | [diff] [blame] | 3316 | snprintf(path, sizeof path, "%s/%s", MODULEDIR, name); |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3317 | else |
Benjamin Franzke | b7acce6 | 2011-05-06 23:19:22 +0200 | [diff] [blame] | 3318 | snprintf(path, sizeof path, "%s", name); |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3319 | |
Pekka Paalanen | 1b3c1ea | 2012-06-11 14:06:04 +0300 | [diff] [blame] | 3320 | weston_log("Loading module '%s'\n", path); |
Kristian Høgsberg | 1acd9f8 | 2012-07-26 11:39:26 -0400 | [diff] [blame] | 3321 | module = dlopen(path, RTLD_NOW); |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3322 | if (!module) { |
Pekka Paalanen | 1b3c1ea | 2012-06-11 14:06:04 +0300 | [diff] [blame] | 3323 | weston_log("Failed to load module: %s\n", dlerror()); |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3324 | return NULL; |
| 3325 | } |
| 3326 | |
| 3327 | init = dlsym(module, entrypoint); |
| 3328 | if (!init) { |
Pekka Paalanen | 1b3c1ea | 2012-06-11 14:06:04 +0300 | [diff] [blame] | 3329 | weston_log("Failed to lookup init function: %s\n", dlerror()); |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3330 | return NULL; |
| 3331 | } |
| 3332 | |
| 3333 | return init; |
| 3334 | } |
| 3335 | |
Pekka Paalanen | 78a0b57 | 2012-06-06 16:59:44 +0300 | [diff] [blame] | 3336 | static const char xdg_error_message[] = |
Martin Minarik | 37032f8 | 2012-06-18 20:15:18 +0200 | [diff] [blame] | 3337 | "fatal: environment variable XDG_RUNTIME_DIR is not set.\n"; |
| 3338 | |
| 3339 | static const char xdg_wrong_message[] = |
| 3340 | "fatal: environment variable XDG_RUNTIME_DIR\n" |
| 3341 | "is set to \"%s\", which is not a directory.\n"; |
| 3342 | |
| 3343 | static const char xdg_wrong_mode_message[] = |
| 3344 | "warning: XDG_RUNTIME_DIR \"%s\" is not configured\n" |
| 3345 | "correctly. Unix access mode must be 0700 but is %o,\n" |
| 3346 | "and XDG_RUNTIME_DIR must be owned by the user, but is\n" |
Kristian Høgsberg | 3033425 | 2012-06-20 14:24:21 -0400 | [diff] [blame] | 3347 | "owned by UID %d.\n"; |
Martin Minarik | 37032f8 | 2012-06-18 20:15:18 +0200 | [diff] [blame] | 3348 | |
| 3349 | static const char xdg_detail_message[] = |
Pekka Paalanen | 78a0b57 | 2012-06-06 16:59:44 +0300 | [diff] [blame] | 3350 | "Refer to your distribution on how to get it, or\n" |
| 3351 | "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n" |
| 3352 | "on how to implement it.\n"; |
| 3353 | |
Martin Minarik | 37032f8 | 2012-06-18 20:15:18 +0200 | [diff] [blame] | 3354 | static void |
| 3355 | verify_xdg_runtime_dir(void) |
| 3356 | { |
| 3357 | char *dir = getenv("XDG_RUNTIME_DIR"); |
| 3358 | struct stat s; |
| 3359 | |
| 3360 | if (!dir) { |
| 3361 | weston_log(xdg_error_message); |
| 3362 | weston_log_continue(xdg_detail_message); |
| 3363 | exit(EXIT_FAILURE); |
| 3364 | } |
| 3365 | |
| 3366 | if (stat(dir, &s) || !S_ISDIR(s.st_mode)) { |
| 3367 | weston_log(xdg_wrong_message, dir); |
| 3368 | weston_log_continue(xdg_detail_message); |
| 3369 | exit(EXIT_FAILURE); |
| 3370 | } |
| 3371 | |
| 3372 | if ((s.st_mode & 0777) != 0700 || s.st_uid != getuid()) { |
| 3373 | weston_log(xdg_wrong_mode_message, |
| 3374 | dir, s.st_mode & 0777, s.st_uid); |
| 3375 | weston_log_continue(xdg_detail_message); |
| 3376 | } |
| 3377 | } |
| 3378 | |
Kristian Høgsberg | 572c2ff | 2012-07-30 15:41:14 -0400 | [diff] [blame] | 3379 | static int |
| 3380 | usage(int error_code) |
| 3381 | { |
| 3382 | fprintf(stderr, |
| 3383 | "Usage: weston [OPTIONS]\n\n" |
| 3384 | "This is weston version " VERSION ", the Wayland reference compositor.\n" |
| 3385 | "Weston supports multiple backends, and depending on which backend is in use\n" |
| 3386 | "different options will be accepted.\n\n" |
| 3387 | |
| 3388 | |
| 3389 | "Core options:\n\n" |
| 3390 | " -B, --backend=MODULE\tBackend module, one of drm-backend.so,\n" |
| 3391 | "\t\t\t\tx11-backend.so or wayland-backend.so\n" |
| 3392 | " -S, --socket=NAME\tName of socket to listen on\n" |
| 3393 | " -i, --idle-time=SECS\tIdle time in seconds\n" |
| 3394 | " --xserver\t\tEnable X server integration\n" |
| 3395 | " --module\t\tLoad the specified module\n" |
| 3396 | " --log==FILE\t\tLog to the given file\n" |
| 3397 | " -h, --help\t\tThis help message\n\n"); |
| 3398 | |
| 3399 | fprintf(stderr, |
| 3400 | "Options for drm-backend.so:\n\n" |
| 3401 | " --connector=ID\tBring up only this connector\n" |
| 3402 | " --seat=SEAT\t\tThe seat that weston should run on\n" |
| 3403 | " --tty=TTY\t\tThe tty to use\n" |
| 3404 | " --current-mode\tPrefer current KMS mode over EDID preferred mode\n\n"); |
| 3405 | |
| 3406 | fprintf(stderr, |
| 3407 | "Options for x11-backend.so:\n\n" |
| 3408 | " --width=WIDTH\t\tWidth of X window\n" |
| 3409 | " --height=HEIGHT\tHeight of X window\n" |
| 3410 | " --fullscreen\t\tRun in fullscreen mode\n" |
| 3411 | " --output-count=COUNT\tCreate multiple outputs\n" |
| 3412 | " --no-input\t\tDont create input devices\n\n"); |
| 3413 | |
| 3414 | fprintf(stderr, |
| 3415 | "Options for wayland-backend.so:\n\n" |
| 3416 | " --width=WIDTH\t\tWidth of Wayland surface\n" |
| 3417 | " --height=HEIGHT\tHeight of Wayland surface\n" |
| 3418 | " --display=DISPLAY\tWayland display to connect to\n\n"); |
| 3419 | |
| 3420 | exit(error_code); |
| 3421 | } |
| 3422 | |
Kristian Høgsberg | 122912c | 2008-12-05 11:13:50 -0500 | [diff] [blame] | 3423 | int main(int argc, char *argv[]) |
| 3424 | { |
Pekka Paalanen | 3ab7269 | 2012-06-08 17:27:28 +0300 | [diff] [blame] | 3425 | int ret = EXIT_SUCCESS; |
Kristian Høgsberg | 122912c | 2008-12-05 11:13:50 -0500 | [diff] [blame] | 3426 | struct wl_display *display; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 3427 | struct weston_compositor *ec; |
Pekka Paalanen | 51c769f | 2012-01-02 16:03:26 +0200 | [diff] [blame] | 3428 | struct wl_event_source *signals[4]; |
Kristian Høgsberg | 50dc698 | 2010-12-01 16:43:56 -0500 | [diff] [blame] | 3429 | struct wl_event_loop *loop; |
Kristian Høgsberg | 0690da6 | 2012-01-16 11:53:54 -0500 | [diff] [blame] | 3430 | struct sigaction segv_action; |
Kristian Høgsberg | d012e9d | 2012-04-12 10:37:23 -0400 | [diff] [blame] | 3431 | void *shell_module, *backend_module, *xserver_module; |
Kristian Høgsberg | 306e361 | 2012-04-12 12:54:14 -0400 | [diff] [blame] | 3432 | int (*module_init)(struct weston_compositor *ec); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 3433 | struct weston_compositor |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3434 | *(*backend_init)(struct wl_display *display, |
Daniel Stone | c1be8e5 | 2012-06-01 11:14:02 -0400 | [diff] [blame] | 3435 | int argc, char *argv[], const char *config_file); |
Pekka Paalanen | 51c769f | 2012-01-02 16:03:26 +0200 | [diff] [blame] | 3436 | int i; |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3437 | char *backend = NULL; |
| 3438 | char *shell = NULL; |
Kristian Høgsberg | 306e361 | 2012-04-12 12:54:14 -0400 | [diff] [blame] | 3439 | char *module = NULL; |
Martin Minarik | 19e6f26 | 2012-06-07 13:08:46 +0200 | [diff] [blame] | 3440 | char *log = NULL; |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3441 | int32_t idle_time = 300; |
Scott Moreau | e17f610 | 2012-04-25 10:03:06 -0600 | [diff] [blame] | 3442 | int32_t xserver = 0; |
Kristian Høgsberg | 572c2ff | 2012-07-30 15:41:14 -0400 | [diff] [blame] | 3443 | int32_t help = 0; |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3444 | char *socket_name = NULL; |
Tiago Vignatti | 9a206c4 | 2012-03-21 19:49:18 +0200 | [diff] [blame] | 3445 | char *config_file; |
| 3446 | |
Kristian Høgsberg | 875ab9e | 2012-03-30 11:52:39 -0400 | [diff] [blame] | 3447 | const struct config_key shell_config_keys[] = { |
Tiago Vignatti | 9a206c4 | 2012-03-21 19:49:18 +0200 | [diff] [blame] | 3448 | { "type", CONFIG_KEY_STRING, &shell }, |
| 3449 | }; |
| 3450 | |
Kristian Høgsberg | 875ab9e | 2012-03-30 11:52:39 -0400 | [diff] [blame] | 3451 | const struct config_section cs[] = { |
Tiago Vignatti | 9a206c4 | 2012-03-21 19:49:18 +0200 | [diff] [blame] | 3452 | { "shell", |
| 3453 | shell_config_keys, ARRAY_LENGTH(shell_config_keys) }, |
| 3454 | }; |
Kristian Høgsberg | d34912c | 2011-05-02 10:36:04 -0400 | [diff] [blame] | 3455 | |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3456 | const struct weston_option core_options[] = { |
| 3457 | { WESTON_OPTION_STRING, "backend", 'B', &backend }, |
| 3458 | { WESTON_OPTION_STRING, "socket", 'S', &socket_name }, |
| 3459 | { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time }, |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3460 | { WESTON_OPTION_BOOLEAN, "xserver", 0, &xserver }, |
Kristian Høgsberg | 306e361 | 2012-04-12 12:54:14 -0400 | [diff] [blame] | 3461 | { WESTON_OPTION_STRING, "module", 0, &module }, |
Martin Minarik | 19e6f26 | 2012-06-07 13:08:46 +0200 | [diff] [blame] | 3462 | { WESTON_OPTION_STRING, "log", 0, &log }, |
Kristian Høgsberg | 572c2ff | 2012-07-30 15:41:14 -0400 | [diff] [blame] | 3463 | { WESTON_OPTION_BOOLEAN, "help", 'h', &help }, |
Kristian Høgsberg | d34912c | 2011-05-02 10:36:04 -0400 | [diff] [blame] | 3464 | }; |
Kristian Høgsberg | d653126 | 2008-12-12 11:06:18 -0500 | [diff] [blame] | 3465 | |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3466 | argc = parse_options(core_options, |
| 3467 | ARRAY_LENGTH(core_options), argc, argv); |
Kristian Høgsberg | 122912c | 2008-12-05 11:13:50 -0500 | [diff] [blame] | 3468 | |
Kristian Høgsberg | 572c2ff | 2012-07-30 15:41:14 -0400 | [diff] [blame] | 3469 | if (help) |
| 3470 | usage(EXIT_SUCCESS); |
| 3471 | |
Rafal Mielniczuk | 6e0a7d8 | 2012-06-09 15:10:28 +0200 | [diff] [blame] | 3472 | weston_log_file_open(log); |
| 3473 | |
Pekka Paalanen | bce4c2b | 2012-06-11 14:04:21 +0300 | [diff] [blame] | 3474 | weston_log("%s\n" |
| 3475 | STAMP_SPACE "%s\n" |
| 3476 | STAMP_SPACE "Bug reports to: %s\n" |
| 3477 | STAMP_SPACE "Build: %s\n", |
| 3478 | PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT, |
Kristian Høgsberg | 23cf9eb | 2012-06-11 12:06:30 -0400 | [diff] [blame] | 3479 | BUILD_ID); |
Pekka Paalanen | 7f4d1a3 | 2012-06-11 14:06:03 +0300 | [diff] [blame] | 3480 | log_uname(); |
Kristian Høgsberg | a411c8b | 2012-06-08 16:16:52 -0400 | [diff] [blame] | 3481 | |
Martin Minarik | 37032f8 | 2012-06-18 20:15:18 +0200 | [diff] [blame] | 3482 | verify_xdg_runtime_dir(); |
| 3483 | |
Kristian Høgsberg | 122912c | 2008-12-05 11:13:50 -0500 | [diff] [blame] | 3484 | display = wl_display_create(); |
| 3485 | |
Tiago Vignatti | 2116b89 | 2011-08-08 05:52:59 -0700 | [diff] [blame] | 3486 | loop = wl_display_get_event_loop(display); |
Pekka Paalanen | 51c769f | 2012-01-02 16:03:26 +0200 | [diff] [blame] | 3487 | signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal, |
| 3488 | display); |
| 3489 | signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal, |
| 3490 | display); |
| 3491 | signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal, |
| 3492 | display); |
Tiago Vignatti | 2116b89 | 2011-08-08 05:52:59 -0700 | [diff] [blame] | 3493 | |
| 3494 | wl_list_init(&child_process_list); |
Pekka Paalanen | 51c769f | 2012-01-02 16:03:26 +0200 | [diff] [blame] | 3495 | signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler, |
| 3496 | NULL); |
Kristian Høgsberg | a941022 | 2011-01-14 17:22:35 -0500 | [diff] [blame] | 3497 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3498 | if (!backend) { |
| 3499 | if (getenv("WAYLAND_DISPLAY")) |
| 3500 | backend = "wayland-backend.so"; |
| 3501 | else if (getenv("DISPLAY")) |
| 3502 | backend = "x11-backend.so"; |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3503 | else |
| 3504 | backend = "drm-backend.so"; |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 3505 | } |
| 3506 | |
Tiago Vignatti | 9a206c4 | 2012-03-21 19:49:18 +0200 | [diff] [blame] | 3507 | config_file = config_file_path("weston.ini"); |
| 3508 | parse_config_file(config_file, cs, ARRAY_LENGTH(cs), shell); |
Kristian Høgsberg | 3df6384 | 2012-07-31 14:54:48 -0400 | [diff] [blame] | 3509 | if (socket_name) |
| 3510 | setenv("WAYLAND_DISPLAY", socket_name, 1); |
Tiago Vignatti | 9a206c4 | 2012-03-21 19:49:18 +0200 | [diff] [blame] | 3511 | |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 3512 | backend_init = load_module(backend, "backend_init", &backend_module); |
| 3513 | if (!backend_init) |
| 3514 | exit(EXIT_FAILURE); |
Kristian Høgsberg | a941022 | 2011-01-14 17:22:35 -0500 | [diff] [blame] | 3515 | |
Daniel Stone | c1be8e5 | 2012-06-01 11:14:02 -0400 | [diff] [blame] | 3516 | ec = backend_init(display, argc, argv, config_file); |
Kristian Høgsberg | 841883b | 2008-12-05 11:19:56 -0500 | [diff] [blame] | 3517 | if (ec == NULL) { |
Pekka Paalanen | 3361639 | 2012-07-30 16:56:57 +0300 | [diff] [blame] | 3518 | weston_log("fatal: failed to create compositor\n"); |
Kristian Høgsberg | 841883b | 2008-12-05 11:19:56 -0500 | [diff] [blame] | 3519 | exit(EXIT_FAILURE); |
| 3520 | } |
Kristian Høgsberg | 61a8251 | 2010-10-26 11:26:44 -0400 | [diff] [blame] | 3521 | |
Kristian Høgsberg | 7b884bc | 2012-07-31 14:32:01 -0400 | [diff] [blame] | 3522 | segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND; |
| 3523 | segv_action.sa_sigaction = on_segv_signal; |
| 3524 | sigemptyset(&segv_action.sa_mask); |
| 3525 | sigaction(SIGSEGV, &segv_action, NULL); |
| 3526 | segv_compositor = ec; |
| 3527 | |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3528 | for (i = 1; argv[i]; i++) |
Pekka Paalanen | 3361639 | 2012-07-30 16:56:57 +0300 | [diff] [blame] | 3529 | weston_log("fatal: unhandled option: %s\n", argv[i]); |
| 3530 | if (argv[1]) { |
| 3531 | ret = EXIT_FAILURE; |
| 3532 | goto out; |
| 3533 | } |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3534 | |
Daniel Stone | c1be8e5 | 2012-06-01 11:14:02 -0400 | [diff] [blame] | 3535 | free(config_file); |
Daniel Stone | 855028f | 2012-05-01 20:37:10 +0100 | [diff] [blame] | 3536 | |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3537 | ec->option_idle_time = idle_time; |
| 3538 | ec->idle_time = idle_time; |
Pekka Paalanen | 7296e79 | 2011-12-07 16:22:00 +0200 | [diff] [blame] | 3539 | |
Kristian Høgsberg | 306e361 | 2012-04-12 12:54:14 -0400 | [diff] [blame] | 3540 | module_init = NULL; |
Kristian Høgsberg | d012e9d | 2012-04-12 10:37:23 -0400 | [diff] [blame] | 3541 | if (xserver) |
Tiago Vignatti | 629ce23 | 2012-05-23 23:04:14 +0300 | [diff] [blame] | 3542 | module_init = load_module("xwayland.so", |
Kristian Høgsberg | 306e361 | 2012-04-12 12:54:14 -0400 | [diff] [blame] | 3543 | "weston_xserver_init", |
| 3544 | &xserver_module); |
Pekka Paalanen | 3361639 | 2012-07-30 16:56:57 +0300 | [diff] [blame] | 3545 | if (module_init && module_init(ec) < 0) { |
| 3546 | ret = EXIT_FAILURE; |
| 3547 | goto out; |
| 3548 | } |
Kristian Høgsberg | d012e9d | 2012-04-12 10:37:23 -0400 | [diff] [blame] | 3549 | |
Kristian Høgsberg | 306e361 | 2012-04-12 12:54:14 -0400 | [diff] [blame] | 3550 | if (!shell) |
| 3551 | shell = "desktop-shell.so"; |
| 3552 | module_init = load_module(shell, "shell_init", &shell_module); |
Pekka Paalanen | 3361639 | 2012-07-30 16:56:57 +0300 | [diff] [blame] | 3553 | if (!module_init || module_init(ec) < 0) { |
| 3554 | ret = EXIT_FAILURE; |
| 3555 | goto out; |
| 3556 | } |
Kristian Høgsberg | 306e361 | 2012-04-12 12:54:14 -0400 | [diff] [blame] | 3557 | |
| 3558 | |
| 3559 | module_init = NULL; |
| 3560 | if (module) |
| 3561 | module_init = load_module(module, "module_init", NULL); |
Pekka Paalanen | 3361639 | 2012-07-30 16:56:57 +0300 | [diff] [blame] | 3562 | if (module_init && module_init(ec) < 0) { |
| 3563 | ret = EXIT_FAILURE; |
| 3564 | goto out; |
| 3565 | } |
Tiago Vignatti | e4faa2a | 2012-04-16 17:31:44 +0300 | [diff] [blame] | 3566 | |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 3567 | if (wl_display_add_socket(display, socket_name)) { |
Pekka Paalanen | 3361639 | 2012-07-30 16:56:57 +0300 | [diff] [blame] | 3568 | weston_log("fatal: failed to add socket: %m\n"); |
| 3569 | ret = EXIT_FAILURE; |
| 3570 | goto out; |
Kristian Høgsberg | 122912c | 2008-12-05 11:13:50 -0500 | [diff] [blame] | 3571 | } |
| 3572 | |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 3573 | weston_compositor_dpms_on(ec); |
Pekka Paalanen | c0444e3 | 2012-01-05 16:28:21 +0200 | [diff] [blame] | 3574 | weston_compositor_wake(ec); |
Kristian Høgsberg | 122912c | 2008-12-05 11:13:50 -0500 | [diff] [blame] | 3575 | |
Kristian Høgsberg | 7b884bc | 2012-07-31 14:32:01 -0400 | [diff] [blame] | 3576 | wl_display_run(display); |
| 3577 | |
| 3578 | out: |
Pekka Paalanen | 0135abe | 2012-01-03 10:01:20 +0200 | [diff] [blame] | 3579 | /* prevent further rendering while shutting down */ |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 3580 | ec->state = WESTON_COMPOSITOR_SLEEPING; |
Pekka Paalanen | 0135abe | 2012-01-03 10:01:20 +0200 | [diff] [blame] | 3581 | |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 3582 | wl_signal_emit(&ec->destroy_signal, ec); |
Pekka Paalanen | 3c64723 | 2011-12-22 13:43:43 +0200 | [diff] [blame] | 3583 | |
Kristian Høgsberg | b5819dc | 2011-04-25 15:08:20 -0400 | [diff] [blame] | 3584 | if (ec->has_bind_display) |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 3585 | ec->unbind_display(ec->egl_display, display); |
Kristian Høgsberg | 2bb3ebe | 2010-12-01 15:36:20 -0500 | [diff] [blame] | 3586 | |
Pekka Paalanen | 51c769f | 2012-01-02 16:03:26 +0200 | [diff] [blame] | 3587 | for (i = ARRAY_LENGTH(signals); i;) |
| 3588 | wl_event_source_remove(signals[--i]); |
| 3589 | |
Daniel Stone | 855028f | 2012-05-01 20:37:10 +0100 | [diff] [blame] | 3590 | weston_compositor_xkb_destroy(ec); |
| 3591 | |
Kristian Høgsberg | caa6442 | 2010-12-01 16:52:15 -0500 | [diff] [blame] | 3592 | ec->destroy(ec); |
Tiago Vignatti | 9e2be08 | 2011-12-19 00:04:46 +0200 | [diff] [blame] | 3593 | wl_display_destroy(display); |
Kristian Høgsberg | caa6442 | 2010-12-01 16:52:15 -0500 | [diff] [blame] | 3594 | |
Martin Minarik | 19e6f26 | 2012-06-07 13:08:46 +0200 | [diff] [blame] | 3595 | weston_log_file_close(); |
| 3596 | |
Pekka Paalanen | 3ab7269 | 2012-06-08 17:27:28 +0300 | [diff] [blame] | 3597 | return ret; |
Kristian Høgsberg | 16eb675 | 2008-10-08 22:51:32 -0400 | [diff] [blame] | 3598 | } |