Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 1 | /* |
Kristian Høgsberg | 96aa7da | 2011-09-15 15:43:14 -0400 | [diff] [blame] | 2 | * Copyright © 2010-2011 Benjamin Franzke |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 3 | * |
Kristian Høgsberg | 96aa7da | 2011-09-15 15:43:14 -0400 | [diff] [blame] | 4 | * Permission to use, copy, modify, distribute, and sell this software and |
| 5 | * its documentation for any purpose is hereby granted without fee, provided |
| 6 | * that the above copyright notice appear in all copies and that both that |
| 7 | * copyright notice and this permission notice appear in supporting |
| 8 | * documentation, and that the name of the copyright holders not be used in |
| 9 | * advertising or publicity pertaining to distribution of the software |
| 10 | * without specific, written prior permission. The copyright holders make |
| 11 | * no representations about the suitability of this software for any |
| 12 | * purpose. It is provided "as is" without express or implied warranty. |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 13 | * |
Kristian Høgsberg | 96aa7da | 2011-09-15 15:43:14 -0400 | [diff] [blame] | 14 | * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS |
| 15 | * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| 16 | * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| 17 | * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER |
| 18 | * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF |
| 19 | * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 20 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 21 | */ |
| 22 | |
| 23 | #ifdef HAVE_CONFIG_H |
| 24 | #include <config.h> |
| 25 | #endif |
| 26 | |
| 27 | #include <stddef.h> |
| 28 | #define _GNU_SOURCE |
| 29 | #include <stdio.h> |
| 30 | #include <stdlib.h> |
| 31 | #include <string.h> |
| 32 | #include <fcntl.h> |
| 33 | #include <unistd.h> |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 34 | #include <sys/mman.h> |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 35 | |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 36 | #include <wayland-client.h> |
| 37 | #include <wayland-egl.h> |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 38 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 39 | #include <GLES2/gl2.h> |
| 40 | #include <GLES2/gl2ext.h> |
| 41 | #include <EGL/egl.h> |
| 42 | #include <EGL/eglext.h> |
| 43 | |
| 44 | #include "compositor.h" |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 45 | #include "log.h" |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 46 | |
| 47 | struct wayland_compositor { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 48 | struct weston_compositor base; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 49 | |
Kristian Høgsberg | b5ef591 | 2012-03-28 22:53:49 -0400 | [diff] [blame] | 50 | struct wl_egl_pixmap *dummy_pixmap; |
Kristian Høgsberg | b71302e | 2012-05-10 12:28:35 -0400 | [diff] [blame] | 51 | EGLSurface dummy_egl_surface; |
Kristian Høgsberg | b5ef591 | 2012-03-28 22:53:49 -0400 | [diff] [blame] | 52 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 53 | struct { |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 54 | struct wl_display *wl_display; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 55 | struct wl_compositor *compositor; |
| 56 | struct wl_shell *shell; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 57 | struct wl_output *output; |
| 58 | |
| 59 | struct { |
| 60 | int32_t x, y, width, height; |
| 61 | } screen_allocation; |
| 62 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 63 | struct wl_event_source *wl_source; |
| 64 | uint32_t event_mask; |
| 65 | } parent; |
| 66 | |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 67 | struct { |
| 68 | int32_t top, bottom, left, right; |
| 69 | GLuint texture; |
| 70 | int32_t width, height; |
| 71 | } border; |
| 72 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 73 | struct wl_list input_list; |
| 74 | }; |
| 75 | |
| 76 | struct wayland_output { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 77 | struct weston_output base; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 78 | |
| 79 | struct { |
| 80 | struct wl_surface *surface; |
Pekka Paalanen | 9d1613e | 2011-11-25 12:09:16 +0200 | [diff] [blame] | 81 | struct wl_shell_surface *shell_surface; |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 82 | struct wl_egl_window *egl_window; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 83 | } parent; |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 84 | EGLSurface egl_surface; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 85 | struct weston_mode mode; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 86 | }; |
| 87 | |
| 88 | struct wayland_input { |
| 89 | struct wayland_compositor *compositor; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 90 | struct wl_seat *seat; |
| 91 | struct wl_pointer *pointer; |
| 92 | struct wl_keyboard *keyboard; |
| 93 | struct wl_touch *touch; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 94 | struct wl_list link; |
Daniel Stone | 5069280 | 2012-06-22 13:21:41 +0100 | [diff] [blame] | 95 | uint32_t key_serial; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 96 | }; |
| 97 | |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 98 | |
| 99 | static int |
| 100 | texture_border(struct wayland_output *output) |
| 101 | { |
| 102 | struct wayland_compositor *c = |
| 103 | (struct wayland_compositor *) output->base.compositor; |
| 104 | GLfloat *d; |
| 105 | unsigned int *p; |
| 106 | int i, j, k, n; |
| 107 | GLfloat x[4], y[4], u[4], v[4]; |
| 108 | |
| 109 | x[0] = -c->border.left; |
| 110 | x[1] = 0; |
| 111 | x[2] = output->base.current->width; |
| 112 | x[3] = output->base.current->width + c->border.right; |
| 113 | |
| 114 | y[0] = -c->border.top; |
| 115 | y[1] = 0; |
| 116 | y[2] = output->base.current->height; |
| 117 | y[3] = output->base.current->height + c->border.bottom; |
| 118 | |
| 119 | u[0] = 0.0; |
| 120 | u[1] = (GLfloat) c->border.left / c->border.width; |
| 121 | u[2] = (GLfloat) (c->border.width - c->border.right) / c->border.width; |
| 122 | u[3] = 1.0; |
| 123 | |
| 124 | v[0] = 0.0; |
| 125 | v[1] = (GLfloat) c->border.top / c->border.height; |
| 126 | v[2] = (GLfloat) (c->border.height - c->border.bottom) / c->border.height; |
| 127 | v[3] = 1.0; |
| 128 | |
| 129 | n = 8; |
| 130 | d = wl_array_add(&c->base.vertices, n * 16 * sizeof *d); |
| 131 | p = wl_array_add(&c->base.indices, n * 6 * sizeof *p); |
| 132 | |
| 133 | k = 0; |
| 134 | for (i = 0; i < 3; i++) |
| 135 | for (j = 0; j < 3; j++) { |
| 136 | |
| 137 | if (i == 1 && j == 1) |
| 138 | continue; |
| 139 | |
| 140 | d[ 0] = x[i]; |
| 141 | d[ 1] = y[j]; |
| 142 | d[ 2] = u[i]; |
| 143 | d[ 3] = v[j]; |
| 144 | |
| 145 | d[ 4] = x[i]; |
| 146 | d[ 5] = y[j + 1]; |
| 147 | d[ 6] = u[i]; |
| 148 | d[ 7] = v[j + 1]; |
| 149 | |
| 150 | d[ 8] = x[i + 1]; |
| 151 | d[ 9] = y[j]; |
| 152 | d[10] = u[i + 1]; |
| 153 | d[11] = v[j]; |
| 154 | |
| 155 | d[12] = x[i + 1]; |
| 156 | d[13] = y[j + 1]; |
| 157 | d[14] = u[i + 1]; |
| 158 | d[15] = v[j + 1]; |
| 159 | |
| 160 | p[0] = k + 0; |
| 161 | p[1] = k + 1; |
| 162 | p[2] = k + 2; |
| 163 | p[3] = k + 2; |
| 164 | p[4] = k + 1; |
| 165 | p[5] = k + 3; |
| 166 | |
| 167 | d += 16; |
| 168 | p += 6; |
| 169 | k += 4; |
| 170 | } |
| 171 | |
| 172 | return k / 4; |
| 173 | } |
| 174 | |
| 175 | static void |
| 176 | draw_border(struct wayland_output *output) |
| 177 | { |
| 178 | struct wayland_compositor *c = |
| 179 | (struct wayland_compositor *) output->base.compositor; |
Gwenole Beauchesne | 6d03049 | 2012-04-20 11:15:51 +0200 | [diff] [blame] | 180 | struct weston_shader *shader = &c->base.texture_shader_rgba; |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 181 | GLfloat *v; |
| 182 | int n; |
| 183 | |
| 184 | glDisable(GL_BLEND); |
| 185 | glUseProgram(shader->program); |
| 186 | c->base.current_shader = shader; |
| 187 | |
| 188 | glUniformMatrix4fv(shader->proj_uniform, |
| 189 | 1, GL_FALSE, output->base.matrix.d); |
| 190 | |
Gwenole Beauchesne | 28f59b0 | 2012-04-20 11:44:06 +0200 | [diff] [blame] | 191 | glUniform1i(shader->tex_uniforms[0], 0); |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 192 | glUniform1f(shader->alpha_uniform, 1); |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 193 | glUniform1f(shader->texwidth_uniform, 1); |
| 194 | |
| 195 | n = texture_border(output); |
| 196 | |
| 197 | glBindTexture(GL_TEXTURE_2D, c->border.texture); |
| 198 | |
| 199 | v = c->base.vertices.data; |
| 200 | glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]); |
| 201 | glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]); |
| 202 | glEnableVertexAttribArray(0); |
| 203 | glEnableVertexAttribArray(1); |
| 204 | |
| 205 | glDrawElements(GL_TRIANGLES, n * 6, |
| 206 | GL_UNSIGNED_INT, c->base.indices.data); |
| 207 | |
| 208 | glDisableVertexAttribArray(1); |
| 209 | glDisableVertexAttribArray(0); |
| 210 | |
| 211 | c->base.vertices.size = 0; |
| 212 | c->base.indices.size = 0; |
| 213 | } |
| 214 | |
| 215 | static void |
| 216 | create_border(struct wayland_compositor *c) |
| 217 | { |
Ander Conselvan de Oliveira | e2d21e8 | 2012-03-16 17:25:09 +0200 | [diff] [blame] | 218 | pixman_image_t *image; |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 219 | |
Ander Conselvan de Oliveira | e2d21e8 | 2012-03-16 17:25:09 +0200 | [diff] [blame] | 220 | image = load_image(DATADIR "/weston/border.png"); |
| 221 | if (!image) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 222 | weston_log("could'nt load border image\n"); |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 223 | return; |
| 224 | } |
| 225 | |
Ander Conselvan de Oliveira | e2d21e8 | 2012-03-16 17:25:09 +0200 | [diff] [blame] | 226 | c->border.width = pixman_image_get_width(image); |
| 227 | c->border.height = pixman_image_get_height(image); |
| 228 | |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 229 | glGenTextures(1, &c->border.texture); |
| 230 | glBindTexture(GL_TEXTURE_2D, c->border.texture); |
| 231 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| 232 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| 233 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| 234 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| 235 | |
| 236 | glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, |
| 237 | c->border.width, |
| 238 | c->border.height, |
Ander Conselvan de Oliveira | e2d21e8 | 2012-03-16 17:25:09 +0200 | [diff] [blame] | 239 | 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, |
| 240 | pixman_image_get_data(image)); |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 241 | |
| 242 | c->border.top = 25; |
| 243 | c->border.bottom = 50; |
| 244 | c->border.left = 25; |
| 245 | c->border.right = 25; |
Ander Conselvan de Oliveira | e2d21e8 | 2012-03-16 17:25:09 +0200 | [diff] [blame] | 246 | |
| 247 | pixman_image_unref(image); |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 248 | } |
| 249 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 250 | static int |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 251 | wayland_compositor_init_egl(struct wayland_compositor *c) |
| 252 | { |
| 253 | EGLint major, minor; |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 254 | EGLint n; |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 255 | EGLint config_attribs[] = { |
| 256 | EGL_SURFACE_TYPE, EGL_WINDOW_BIT, |
| 257 | EGL_RED_SIZE, 1, |
| 258 | EGL_GREEN_SIZE, 1, |
| 259 | EGL_BLUE_SIZE, 1, |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 260 | EGL_ALPHA_SIZE, 1, |
Kristian Høgsberg | d28ab36 | 2011-03-02 11:36:30 -0500 | [diff] [blame] | 261 | EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 262 | EGL_NONE |
| 263 | }; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 264 | static const EGLint context_attribs[] = { |
| 265 | EGL_CONTEXT_CLIENT_VERSION, 2, |
| 266 | EGL_NONE |
| 267 | }; |
| 268 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 269 | c->base.egl_display = eglGetDisplay(c->parent.wl_display); |
| 270 | if (c->base.egl_display == NULL) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 271 | weston_log("failed to create display\n"); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 272 | return -1; |
| 273 | } |
| 274 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 275 | if (!eglInitialize(c->base.egl_display, &major, &minor)) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 276 | weston_log("failed to initialize display\n"); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 277 | return -1; |
| 278 | } |
| 279 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 280 | if (!eglBindAPI(EGL_OPENGL_ES_API)) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 281 | weston_log("failed to bind EGL_OPENGL_ES_API\n"); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 282 | return -1; |
| 283 | } |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 284 | if (!eglChooseConfig(c->base.egl_display, config_attribs, |
| 285 | &c->base.egl_config, 1, &n) || n == 0) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 286 | weston_log("failed to choose config: %d\n", n); |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 287 | return -1; |
| 288 | } |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 289 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 290 | c->base.egl_context = |
| 291 | eglCreateContext(c->base.egl_display, c->base.egl_config, |
| 292 | EGL_NO_CONTEXT, context_attribs); |
| 293 | if (c->base.egl_context == NULL) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 294 | weston_log("failed to create context\n"); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 295 | return -1; |
| 296 | } |
| 297 | |
Kristian Høgsberg | b5ef591 | 2012-03-28 22:53:49 -0400 | [diff] [blame] | 298 | c->dummy_pixmap = wl_egl_pixmap_create(10, 10, 0); |
| 299 | if (!c->dummy_pixmap) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 300 | weston_log("failure to create dummy_pixmap\n"); |
Kristian Høgsberg | b5ef591 | 2012-03-28 22:53:49 -0400 | [diff] [blame] | 301 | return -1; |
| 302 | } |
| 303 | |
| 304 | c->dummy_egl_surface = |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 305 | eglCreatePixmapSurface(c->base.egl_display, c->base.egl_config, |
Kristian Høgsberg | b5ef591 | 2012-03-28 22:53:49 -0400 | [diff] [blame] | 306 | c->dummy_pixmap, NULL); |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 307 | if (!eglMakeCurrent(c->base.egl_display, c->dummy_egl_surface, |
| 308 | c->dummy_egl_surface, c->base.egl_context)) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 309 | weston_log("failed to make context current\n"); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 310 | return -1; |
| 311 | } |
| 312 | |
| 313 | return 0; |
| 314 | } |
| 315 | |
Kristian Høgsberg | 68c479a | 2012-01-25 23:32:28 -0500 | [diff] [blame] | 316 | static void |
Kristian Høgsberg | cdd61d0 | 2012-02-07 09:56:15 -0500 | [diff] [blame] | 317 | frame_done(void *data, struct wl_callback *callback, uint32_t time) |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 318 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 319 | struct weston_output *output = data; |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 320 | |
Kristian Høgsberg | cdd61d0 | 2012-02-07 09:56:15 -0500 | [diff] [blame] | 321 | wl_callback_destroy(callback); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 322 | weston_output_finish_frame(output, time); |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 323 | } |
| 324 | |
| 325 | static const struct wl_callback_listener frame_listener = { |
| 326 | frame_done |
| 327 | }; |
| 328 | |
Kristian Høgsberg | 06cf6b0 | 2012-01-25 23:47:45 -0500 | [diff] [blame] | 329 | static void |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 330 | wayland_output_repaint(struct weston_output *output_base, |
| 331 | pixman_region32_t *damage) |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 332 | { |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 333 | struct wayland_output *output = (struct wayland_output *) output_base; |
Kristian Høgsberg | 06cf6b0 | 2012-01-25 23:47:45 -0500 | [diff] [blame] | 334 | struct wayland_compositor *compositor = |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 335 | (struct wayland_compositor *) output->base.compositor; |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 336 | struct wl_callback *callback; |
Kristian Høgsberg | 06cf6b0 | 2012-01-25 23:47:45 -0500 | [diff] [blame] | 337 | struct weston_surface *surface; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 338 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 339 | if (!eglMakeCurrent(compositor->base.egl_display, output->egl_surface, |
| 340 | output->egl_surface, |
| 341 | compositor->base.egl_context)) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 342 | weston_log("failed to make current\n"); |
Kristian Høgsberg | 06cf6b0 | 2012-01-25 23:47:45 -0500 | [diff] [blame] | 343 | return; |
| 344 | } |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 345 | |
Kristian Høgsberg | 06cf6b0 | 2012-01-25 23:47:45 -0500 | [diff] [blame] | 346 | wl_list_for_each_reverse(surface, &compositor->base.surface_list, link) |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 347 | weston_surface_draw(surface, &output->base, damage); |
Kristian Høgsberg | 06cf6b0 | 2012-01-25 23:47:45 -0500 | [diff] [blame] | 348 | |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 349 | draw_border(output); |
| 350 | |
Kristian Høgsberg | e0f832b | 2012-06-20 00:13:18 -0400 | [diff] [blame] | 351 | wl_signal_emit(&output->base.frame_signal, output); |
Scott Moreau | 062be7e | 2012-04-20 13:37:33 -0600 | [diff] [blame] | 352 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 353 | eglSwapBuffers(compositor->base.egl_display, output->egl_surface); |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 354 | callback = wl_surface_frame(output->parent.surface); |
| 355 | wl_callback_add_listener(callback, &frame_listener, output); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 356 | |
Kristian Høgsberg | 06cf6b0 | 2012-01-25 23:47:45 -0500 | [diff] [blame] | 357 | return; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 358 | } |
| 359 | |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 360 | static void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 361 | wayland_output_destroy(struct weston_output *output_base) |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 362 | { |
| 363 | struct wayland_output *output = (struct wayland_output *) output_base; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 364 | struct weston_compositor *ec = output->base.compositor; |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 365 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 366 | eglDestroySurface(ec->egl_display, output->egl_surface); |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 367 | wl_egl_window_destroy(output->parent.egl_window); |
| 368 | free(output); |
| 369 | |
| 370 | return; |
| 371 | } |
| 372 | |
Ander Conselvan de Oliveira | 563c5b8 | 2012-06-18 17:36:21 +0300 | [diff] [blame] | 373 | static const struct wl_shell_surface_listener shell_surface_listener; |
| 374 | |
Benjamin Franzke | 431da9a | 2011-04-20 11:02:58 +0200 | [diff] [blame] | 375 | static int |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 376 | wayland_compositor_create_output(struct wayland_compositor *c, |
| 377 | int width, int height) |
| 378 | { |
| 379 | struct wayland_output *output; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 380 | |
| 381 | output = malloc(sizeof *output); |
| 382 | if (output == NULL) |
| 383 | return -1; |
| 384 | memset(output, 0, sizeof *output); |
| 385 | |
Kristian Høgsberg | 8f0ce05 | 2011-06-21 11:16:58 -0400 | [diff] [blame] | 386 | output->mode.flags = |
| 387 | WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED; |
| 388 | output->mode.width = width; |
| 389 | output->mode.height = height; |
| 390 | output->mode.refresh = 60; |
| 391 | wl_list_init(&output->base.mode_list); |
| 392 | wl_list_insert(&output->base.mode_list, &output->mode.link); |
| 393 | |
| 394 | output->base.current = &output->mode; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 395 | weston_output_init(&output->base, &c->base, 0, 0, width, height, |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 396 | WL_OUTPUT_FLIPPED); |
Kristian Høgsberg | 8f0ce05 | 2011-06-21 11:16:58 -0400 | [diff] [blame] | 397 | |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 398 | output->base.border.top = c->border.top; |
| 399 | output->base.border.bottom = c->border.bottom; |
| 400 | output->base.border.left = c->border.left; |
| 401 | output->base.border.right = c->border.right; |
| 402 | |
| 403 | weston_output_move(&output->base, 0, 0); |
| 404 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 405 | output->parent.surface = |
| 406 | wl_compositor_create_surface(c->parent.compositor); |
| 407 | wl_surface_set_user_data(output->parent.surface, output); |
| 408 | |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 409 | output->parent.egl_window = |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 410 | wl_egl_window_create(output->parent.surface, |
| 411 | width + c->border.left + c->border.right, |
| 412 | height + c->border.top + c->border.bottom); |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 413 | if (!output->parent.egl_window) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 414 | weston_log("failure to create wl_egl_window\n"); |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 415 | goto cleanup_output; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 416 | } |
| 417 | |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 418 | output->egl_surface = |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 419 | eglCreateWindowSurface(c->base.egl_display, c->base.egl_config, |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 420 | output->parent.egl_window, NULL); |
| 421 | if (!output->egl_surface) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 422 | weston_log("failed to create window surface\n"); |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 423 | goto cleanup_window; |
| 424 | } |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 425 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 426 | if (!eglMakeCurrent(c->base.egl_display, output->egl_surface, |
| 427 | output->egl_surface, c->base.egl_context)) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 428 | weston_log("failed to make surface current\n"); |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 429 | goto cleanup_surface; |
| 430 | return -1; |
| 431 | } |
| 432 | |
Pekka Paalanen | 9d1613e | 2011-11-25 12:09:16 +0200 | [diff] [blame] | 433 | output->parent.shell_surface = |
| 434 | wl_shell_get_shell_surface(c->parent.shell, |
| 435 | output->parent.surface); |
Ander Conselvan de Oliveira | 563c5b8 | 2012-06-18 17:36:21 +0300 | [diff] [blame] | 436 | wl_shell_surface_add_listener(output->parent.shell_surface, |
| 437 | &shell_surface_listener, output); |
Pekka Paalanen | 9d1613e | 2011-11-25 12:09:16 +0200 | [diff] [blame] | 438 | wl_shell_surface_set_toplevel(output->parent.shell_surface); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 439 | |
Alex Wu | bd3354b | 2012-04-17 17:20:49 +0800 | [diff] [blame] | 440 | output->base.origin = output->base.current; |
Kristian Høgsberg | 68c479a | 2012-01-25 23:32:28 -0500 | [diff] [blame] | 441 | output->base.repaint = wayland_output_repaint; |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 442 | output->base.destroy = wayland_output_destroy; |
Jesse Barnes | 5308a5e | 2012-02-09 13:12:57 -0800 | [diff] [blame] | 443 | output->base.assign_planes = NULL; |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 444 | output->base.set_backlight = NULL; |
| 445 | output->base.set_dpms = NULL; |
Alex Wu | 2dda604 | 2012-04-17 17:20:47 +0800 | [diff] [blame] | 446 | output->base.switch_mode = NULL; |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 447 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 448 | wl_list_insert(c->base.output_list.prev, &output->base.link); |
| 449 | |
| 450 | return 0; |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 451 | |
| 452 | cleanup_surface: |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 453 | eglDestroySurface(c->base.egl_display, output->egl_surface); |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 454 | cleanup_window: |
| 455 | wl_egl_window_destroy(output->parent.egl_window); |
| 456 | cleanup_output: |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 457 | /* FIXME: cleanup weston_output */ |
Benjamin Franzke | be01456 | 2011-02-18 17:04:24 +0100 | [diff] [blame] | 458 | free(output); |
| 459 | |
| 460 | return -1; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 461 | } |
| 462 | |
Ander Conselvan de Oliveira | 563c5b8 | 2012-06-18 17:36:21 +0300 | [diff] [blame] | 463 | static void |
| 464 | shell_surface_ping(void *data, struct wl_shell_surface *shell_surface, |
| 465 | uint32_t serial) |
| 466 | { |
| 467 | wl_shell_surface_pong(shell_surface, serial); |
| 468 | } |
| 469 | |
| 470 | static void |
| 471 | shell_surface_configure(void *data, struct wl_shell_surface *shell_surface, |
| 472 | uint32_t edges, int32_t width, int32_t height) |
| 473 | { |
| 474 | /* FIXME: implement resizing */ |
| 475 | } |
| 476 | |
| 477 | static void |
| 478 | shell_surface_popup_done(void *data, struct wl_shell_surface *shell_surface) |
| 479 | { |
| 480 | } |
| 481 | |
| 482 | static const struct wl_shell_surface_listener shell_surface_listener = { |
| 483 | shell_surface_ping, |
| 484 | shell_surface_configure, |
| 485 | shell_surface_popup_done |
| 486 | }; |
| 487 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 488 | /* Events received from the wayland-server this compositor is client of: */ |
| 489 | |
| 490 | /* parent output interface */ |
| 491 | static void |
| 492 | display_handle_geometry(void *data, |
Kristian Høgsberg | 8f0ce05 | 2011-06-21 11:16:58 -0400 | [diff] [blame] | 493 | struct wl_output *wl_output, |
| 494 | int x, |
| 495 | int y, |
| 496 | int physical_width, |
| 497 | int physical_height, |
| 498 | int subpixel, |
| 499 | const char *make, |
Kristian Høgsberg | 0e69647 | 2012-07-22 15:49:57 -0400 | [diff] [blame] | 500 | const char *model, |
| 501 | int transform) |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 502 | { |
| 503 | struct wayland_compositor *c = data; |
| 504 | |
Kristian Høgsberg | f8fc08f | 2010-12-01 20:10:10 -0500 | [diff] [blame] | 505 | c->parent.screen_allocation.x = x; |
| 506 | c->parent.screen_allocation.y = y; |
Kristian Høgsberg | 8f0ce05 | 2011-06-21 11:16:58 -0400 | [diff] [blame] | 507 | } |
| 508 | |
| 509 | static void |
| 510 | display_handle_mode(void *data, |
| 511 | struct wl_output *wl_output, |
| 512 | uint32_t flags, |
| 513 | int width, |
| 514 | int height, |
| 515 | int refresh) |
| 516 | { |
| 517 | struct wayland_compositor *c = data; |
| 518 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 519 | c->parent.screen_allocation.width = width; |
| 520 | c->parent.screen_allocation.height = height; |
| 521 | } |
| 522 | |
| 523 | static const struct wl_output_listener output_listener = { |
| 524 | display_handle_geometry, |
Kristian Høgsberg | 8f0ce05 | 2011-06-21 11:16:58 -0400 | [diff] [blame] | 525 | display_handle_mode |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 526 | }; |
| 527 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 528 | /* parent input interface */ |
| 529 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 530 | input_handle_pointer_enter(void *data, struct wl_pointer *pointer, |
| 531 | uint32_t serial, struct wl_surface *surface, |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 532 | wl_fixed_t x, wl_fixed_t y) |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 533 | { |
| 534 | struct wayland_input *input = data; |
Kristian Høgsberg | af82bea | 2011-01-27 20:18:17 -0500 | [diff] [blame] | 535 | struct wayland_output *output; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 536 | struct wayland_compositor *c = input->compositor; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 537 | |
Daniel Stone | 5069280 | 2012-06-22 13:21:41 +0100 | [diff] [blame] | 538 | /* XXX: If we get a modifier event immediately before the focus, |
| 539 | * we should try to keep the same serial. */ |
Kristian Høgsberg | 06d58b7 | 2012-02-23 09:59:05 -0500 | [diff] [blame] | 540 | output = wl_surface_get_user_data(surface); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 541 | notify_pointer_focus(&c->base.seat->seat, &output->base, x, y); |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 542 | wl_pointer_set_cursor(input->pointer, serial, NULL, 0, 0); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 543 | } |
| 544 | |
| 545 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 546 | input_handle_pointer_leave(void *data, struct wl_pointer *pointer, |
| 547 | uint32_t serial, struct wl_surface *surface) |
Kristian Høgsberg | 06d58b7 | 2012-02-23 09:59:05 -0500 | [diff] [blame] | 548 | { |
| 549 | struct wayland_input *input = data; |
| 550 | struct wayland_compositor *c = input->compositor; |
| 551 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 552 | notify_pointer_focus(&c->base.seat->seat, NULL, 0, 0); |
Kristian Høgsberg | 06d58b7 | 2012-02-23 09:59:05 -0500 | [diff] [blame] | 553 | } |
| 554 | |
| 555 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 556 | input_handle_motion(void *data, struct wl_pointer *pointer, |
| 557 | uint32_t time, wl_fixed_t x, wl_fixed_t y) |
| 558 | { |
| 559 | struct wayland_input *input = data; |
| 560 | struct wayland_compositor *c = input->compositor; |
| 561 | |
| 562 | notify_motion(&c->base.seat->seat, time, |
| 563 | x - wl_fixed_from_int(c->border.left), |
| 564 | y - wl_fixed_from_int(c->border.top)); |
| 565 | } |
| 566 | |
| 567 | static void |
| 568 | input_handle_button(void *data, struct wl_pointer *pointer, |
Daniel Stone | 4dbadb1 | 2012-05-30 16:31:51 +0100 | [diff] [blame] | 569 | uint32_t serial, uint32_t time, uint32_t button, |
| 570 | uint32_t state_w) |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 571 | { |
| 572 | struct wayland_input *input = data; |
| 573 | struct wayland_compositor *c = input->compositor; |
Daniel Stone | 4dbadb1 | 2012-05-30 16:31:51 +0100 | [diff] [blame] | 574 | enum wl_pointer_button_state state = state_w; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 575 | |
| 576 | notify_button(&c->base.seat->seat, time, button, state); |
| 577 | } |
| 578 | |
| 579 | static void |
| 580 | input_handle_axis(void *data, struct wl_pointer *pointer, |
Daniel Stone | 2fce402 | 2012-05-30 16:32:00 +0100 | [diff] [blame] | 581 | uint32_t time, uint32_t axis, wl_fixed_t value) |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 582 | { |
| 583 | struct wayland_input *input = data; |
| 584 | struct wayland_compositor *c = input->compositor; |
| 585 | |
Daniel Stone | 2fce402 | 2012-05-30 16:32:00 +0100 | [diff] [blame] | 586 | notify_axis(&c->base.seat->seat, time, axis, value); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 587 | } |
| 588 | |
| 589 | static const struct wl_pointer_listener pointer_listener = { |
| 590 | input_handle_pointer_enter, |
| 591 | input_handle_pointer_leave, |
| 592 | input_handle_motion, |
| 593 | input_handle_button, |
| 594 | input_handle_axis, |
| 595 | }; |
| 596 | |
| 597 | static void |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 598 | input_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, |
| 599 | int fd, uint32_t size) |
| 600 | { |
| 601 | struct wayland_input *input = data; |
| 602 | struct xkb_keymap *keymap; |
| 603 | char *map_str; |
| 604 | |
| 605 | if (!data) { |
| 606 | close(fd); |
| 607 | return; |
| 608 | } |
| 609 | |
| 610 | if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) { |
| 611 | close(fd); |
| 612 | return; |
| 613 | } |
| 614 | |
| 615 | map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0); |
| 616 | if (map_str == MAP_FAILED) { |
| 617 | close(fd); |
| 618 | return; |
| 619 | } |
| 620 | |
| 621 | keymap = xkb_map_new_from_string(input->compositor->base.xkb_context, |
| 622 | map_str, |
| 623 | XKB_KEYMAP_FORMAT_TEXT_V1, |
| 624 | 0); |
| 625 | munmap(map_str, size); |
| 626 | close(fd); |
| 627 | |
| 628 | if (!keymap) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 629 | weston_log("failed to compile keymap\n"); |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 630 | return; |
| 631 | } |
| 632 | |
| 633 | weston_seat_init_keyboard(input->compositor->base.seat, keymap); |
| 634 | xkb_map_unref(keymap); |
| 635 | } |
| 636 | |
| 637 | static void |
Kristian Høgsberg | 06d58b7 | 2012-02-23 09:59:05 -0500 | [diff] [blame] | 638 | input_handle_keyboard_enter(void *data, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 639 | struct wl_keyboard *keyboard, |
| 640 | uint32_t serial, |
Kristian Høgsberg | 06d58b7 | 2012-02-23 09:59:05 -0500 | [diff] [blame] | 641 | struct wl_surface *surface, |
| 642 | struct wl_array *keys) |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 643 | { |
Kristian Høgsberg | af82bea | 2011-01-27 20:18:17 -0500 | [diff] [blame] | 644 | struct wayland_input *input = data; |
| 645 | struct wayland_compositor *c = input->compositor; |
Kristian Høgsberg | af82bea | 2011-01-27 20:18:17 -0500 | [diff] [blame] | 646 | |
Daniel Stone | 5069280 | 2012-06-22 13:21:41 +0100 | [diff] [blame] | 647 | /* XXX: If we get a modifier event immediately before the focus, |
| 648 | * we should try to keep the same serial. */ |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 649 | notify_keyboard_focus_in(&c->base.seat->seat, keys, |
| 650 | STATE_UPDATE_AUTOMATIC); |
Kristian Høgsberg | 06d58b7 | 2012-02-23 09:59:05 -0500 | [diff] [blame] | 651 | } |
| 652 | |
| 653 | static void |
| 654 | input_handle_keyboard_leave(void *data, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 655 | struct wl_keyboard *keyboard, |
| 656 | uint32_t serial, |
Kristian Høgsberg | 06d58b7 | 2012-02-23 09:59:05 -0500 | [diff] [blame] | 657 | struct wl_surface *surface) |
| 658 | { |
| 659 | struct wayland_input *input = data; |
| 660 | struct wayland_compositor *c = input->compositor; |
| 661 | |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 662 | notify_keyboard_focus_out(&c->base.seat->seat); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 663 | } |
| 664 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 665 | static void |
| 666 | input_handle_key(void *data, struct wl_keyboard *keyboard, |
| 667 | uint32_t serial, uint32_t time, uint32_t key, uint32_t state) |
| 668 | { |
| 669 | struct wayland_input *input = data; |
| 670 | struct wayland_compositor *c = input->compositor; |
| 671 | |
Daniel Stone | 5069280 | 2012-06-22 13:21:41 +0100 | [diff] [blame] | 672 | input->key_serial = serial; |
Daniel Stone | c9785ea | 2012-05-30 16:31:52 +0100 | [diff] [blame] | 673 | notify_key(&c->base.seat->seat, time, key, |
| 674 | state ? WL_KEYBOARD_KEY_STATE_PRESSED : |
Daniel Stone | 1b4e11f | 2012-06-22 13:21:37 +0100 | [diff] [blame] | 675 | WL_KEYBOARD_KEY_STATE_RELEASED, |
Daniel Stone | 5069280 | 2012-06-22 13:21:41 +0100 | [diff] [blame] | 676 | STATE_UPDATE_NONE); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 677 | } |
| 678 | |
Daniel Stone | 351eb61 | 2012-05-31 15:27:47 -0400 | [diff] [blame] | 679 | static void |
| 680 | input_handle_modifiers(void *data, struct wl_keyboard *keyboard, |
Daniel Stone | 5069280 | 2012-06-22 13:21:41 +0100 | [diff] [blame] | 681 | uint32_t serial_in, uint32_t mods_depressed, |
Daniel Stone | 351eb61 | 2012-05-31 15:27:47 -0400 | [diff] [blame] | 682 | uint32_t mods_latched, uint32_t mods_locked, |
| 683 | uint32_t group) |
| 684 | { |
Daniel Stone | 5069280 | 2012-06-22 13:21:41 +0100 | [diff] [blame] | 685 | struct wayland_input *input = data; |
| 686 | struct wayland_compositor *c = input->compositor; |
| 687 | uint32_t serial_out; |
| 688 | |
| 689 | /* If we get a key event followed by a modifier event with the |
| 690 | * same serial number, then we try to preserve those semantics by |
| 691 | * reusing the same serial number on the way out too. */ |
| 692 | if (serial_in == input->key_serial) |
| 693 | serial_out = wl_display_get_serial(c->base.wl_display); |
| 694 | else |
| 695 | serial_out = wl_display_next_serial(c->base.wl_display); |
| 696 | |
| 697 | xkb_state_update_mask(c->base.seat->xkb_state.state, |
| 698 | mods_depressed, mods_latched, |
| 699 | mods_locked, 0, 0, group); |
| 700 | notify_modifiers(&c->base.seat->seat, serial_out); |
Daniel Stone | 351eb61 | 2012-05-31 15:27:47 -0400 | [diff] [blame] | 701 | } |
| 702 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 703 | static const struct wl_keyboard_listener keyboard_listener = { |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 704 | input_handle_keymap, |
Kristian Høgsberg | 06d58b7 | 2012-02-23 09:59:05 -0500 | [diff] [blame] | 705 | input_handle_keyboard_enter, |
| 706 | input_handle_keyboard_leave, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 707 | input_handle_key, |
Daniel Stone | 351eb61 | 2012-05-31 15:27:47 -0400 | [diff] [blame] | 708 | input_handle_modifiers, |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 709 | }; |
| 710 | |
| 711 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 712 | input_handle_capabilities(void *data, struct wl_seat *seat, |
| 713 | enum wl_seat_capability caps) |
| 714 | { |
| 715 | struct wayland_input *input = data; |
| 716 | |
| 717 | if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->pointer) { |
| 718 | input->pointer = wl_seat_get_pointer(seat); |
| 719 | wl_pointer_set_user_data(input->pointer, input); |
| 720 | wl_pointer_add_listener(input->pointer, &pointer_listener, |
| 721 | input); |
Daniel Stone | cd981dd | 2012-06-01 12:14:00 +0100 | [diff] [blame] | 722 | weston_seat_init_pointer(input->compositor->base.seat); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 723 | } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && input->pointer) { |
| 724 | wl_pointer_destroy(input->pointer); |
| 725 | input->pointer = NULL; |
| 726 | } |
| 727 | |
| 728 | if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !input->keyboard) { |
| 729 | input->keyboard = wl_seat_get_keyboard(seat); |
| 730 | wl_keyboard_set_user_data(input->keyboard, input); |
| 731 | wl_keyboard_add_listener(input->keyboard, &keyboard_listener, |
| 732 | input); |
| 733 | } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && input->keyboard) { |
| 734 | wl_keyboard_destroy(input->keyboard); |
| 735 | input->keyboard = NULL; |
| 736 | } |
| 737 | } |
| 738 | |
| 739 | static const struct wl_seat_listener seat_listener = { |
| 740 | input_handle_capabilities, |
| 741 | }; |
| 742 | |
| 743 | static void |
| 744 | display_add_seat(struct wayland_compositor *c, uint32_t id) |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 745 | { |
| 746 | struct wayland_input *input; |
| 747 | |
| 748 | input = malloc(sizeof *input); |
| 749 | if (input == NULL) |
| 750 | return; |
| 751 | |
| 752 | memset(input, 0, sizeof *input); |
| 753 | |
| 754 | input->compositor = c; |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 755 | input->seat = wl_display_bind(c->parent.wl_display, id, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 756 | &wl_seat_interface); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 757 | wl_list_insert(c->input_list.prev, &input->link); |
| 758 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 759 | wl_seat_add_listener(input->seat, &seat_listener, input); |
| 760 | wl_seat_set_user_data(input->seat, input); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 761 | } |
| 762 | |
| 763 | static void |
| 764 | display_handle_global(struct wl_display *display, uint32_t id, |
| 765 | const char *interface, uint32_t version, void *data) |
| 766 | { |
| 767 | struct wayland_compositor *c = data; |
| 768 | |
Benjamin Franzke | 080ab6c | 2011-04-30 10:41:27 +0200 | [diff] [blame] | 769 | if (strcmp(interface, "wl_compositor") == 0) { |
Kristian Høgsberg | f790c79 | 2011-08-19 14:41:57 -0400 | [diff] [blame] | 770 | c->parent.compositor = |
| 771 | wl_display_bind(display, id, &wl_compositor_interface); |
Benjamin Franzke | 080ab6c | 2011-04-30 10:41:27 +0200 | [diff] [blame] | 772 | } else if (strcmp(interface, "wl_output") == 0) { |
Kristian Høgsberg | f790c79 | 2011-08-19 14:41:57 -0400 | [diff] [blame] | 773 | c->parent.output = |
| 774 | wl_display_bind(display, id, &wl_output_interface); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 775 | wl_output_add_listener(c->parent.output, &output_listener, c); |
Benjamin Franzke | 080ab6c | 2011-04-30 10:41:27 +0200 | [diff] [blame] | 776 | } else if (strcmp(interface, "wl_shell") == 0) { |
Kristian Høgsberg | f790c79 | 2011-08-19 14:41:57 -0400 | [diff] [blame] | 777 | c->parent.shell = |
| 778 | wl_display_bind(display, id, &wl_shell_interface); |
Daniel Stone | 725c2c3 | 2012-06-22 14:04:36 +0100 | [diff] [blame] | 779 | } else if (strcmp(interface, "wl_seat") == 0) { |
| 780 | display_add_seat(c, id); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 781 | } |
| 782 | } |
| 783 | |
| 784 | static int |
| 785 | update_event_mask(uint32_t mask, void *data) |
| 786 | { |
| 787 | struct wayland_compositor *c = data; |
| 788 | |
| 789 | c->parent.event_mask = mask; |
| 790 | if (c->parent.wl_source) |
| 791 | wl_event_source_fd_update(c->parent.wl_source, mask); |
| 792 | |
| 793 | return 0; |
| 794 | } |
| 795 | |
Kristian Høgsberg | 95d843d | 2011-04-22 13:01:26 -0400 | [diff] [blame] | 796 | static int |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 797 | wayland_compositor_handle_event(int fd, uint32_t mask, void *data) |
| 798 | { |
| 799 | struct wayland_compositor *c = data; |
| 800 | |
| 801 | if (mask & WL_EVENT_READABLE) |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 802 | wl_display_iterate(c->parent.wl_display, WL_DISPLAY_READABLE); |
Kristian Høgsberg | f258a31 | 2011-12-28 22:51:20 -0500 | [diff] [blame] | 803 | if (mask & WL_EVENT_WRITABLE) |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 804 | wl_display_iterate(c->parent.wl_display, WL_DISPLAY_WRITABLE); |
Kristian Høgsberg | 95d843d | 2011-04-22 13:01:26 -0400 | [diff] [blame] | 805 | |
| 806 | return 1; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 807 | } |
| 808 | |
Daniel Stone | a497d57 | 2012-06-04 11:40:46 +0100 | [diff] [blame] | 809 | static int |
| 810 | wayland_input_create(struct wayland_compositor *c) |
| 811 | { |
| 812 | struct weston_seat *seat; |
| 813 | |
| 814 | seat = malloc(sizeof *seat); |
| 815 | if (seat == NULL) |
| 816 | return -1; |
| 817 | |
| 818 | memset(seat, 0, sizeof *seat); |
| 819 | weston_seat_init(seat, &c->base); |
| 820 | |
| 821 | c->base.seat = seat; |
| 822 | |
Daniel Stone | a497d57 | 2012-06-04 11:40:46 +0100 | [diff] [blame] | 823 | return 0; |
| 824 | } |
| 825 | |
Kristian Høgsberg | caa6442 | 2010-12-01 16:52:15 -0500 | [diff] [blame] | 826 | static void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 827 | wayland_destroy(struct weston_compositor *ec) |
Kristian Høgsberg | caa6442 | 2010-12-01 16:52:15 -0500 | [diff] [blame] | 828 | { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 829 | weston_compositor_shutdown(ec); |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 830 | |
Kristian Høgsberg | caa6442 | 2010-12-01 16:52:15 -0500 | [diff] [blame] | 831 | free(ec); |
| 832 | } |
| 833 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 834 | static struct weston_compositor * |
Kristian Høgsberg | 2e28b10 | 2012-02-07 09:57:25 -0500 | [diff] [blame] | 835 | wayland_compositor_create(struct wl_display *display, |
Daniel Stone | baf4359 | 2012-06-01 11:11:10 -0400 | [diff] [blame] | 836 | int width, int height, const char *display_name, |
Daniel Stone | c1be8e5 | 2012-06-01 11:14:02 -0400 | [diff] [blame] | 837 | int argc, char *argv[], const char *config_file) |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 838 | { |
| 839 | struct wayland_compositor *c; |
| 840 | struct wl_event_loop *loop; |
| 841 | int fd; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 842 | |
| 843 | c = malloc(sizeof *c); |
| 844 | if (c == NULL) |
| 845 | return NULL; |
| 846 | |
| 847 | memset(c, 0, sizeof *c); |
| 848 | |
Daniel Stone | 725c2c3 | 2012-06-22 14:04:36 +0100 | [diff] [blame] | 849 | if (weston_compositor_init(&c->base, display, argc, argv, |
| 850 | config_file) < 0) |
Martin Olsson | c5db50f | 2012-07-08 03:03:43 +0200 | [diff] [blame] | 851 | goto err_free; |
Daniel Stone | 725c2c3 | 2012-06-22 14:04:36 +0100 | [diff] [blame] | 852 | |
| 853 | if (wayland_input_create(c) < 0) |
Martin Olsson | c5db50f | 2012-07-08 03:03:43 +0200 | [diff] [blame] | 854 | goto err_compositor; |
Daniel Stone | 725c2c3 | 2012-06-22 14:04:36 +0100 | [diff] [blame] | 855 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 856 | c->parent.wl_display = wl_display_connect(display_name); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 857 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 858 | if (c->parent.wl_display == NULL) { |
Martin Minarik | 6d11836 | 2012-06-07 18:01:59 +0200 | [diff] [blame] | 859 | weston_log("failed to create display: %m\n"); |
Martin Olsson | c5db50f | 2012-07-08 03:03:43 +0200 | [diff] [blame] | 860 | goto err_compositor; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 861 | } |
| 862 | |
| 863 | wl_list_init(&c->input_list); |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 864 | wl_display_add_global_listener(c->parent.wl_display, |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 865 | display_handle_global, c); |
| 866 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 867 | wl_display_iterate(c->parent.wl_display, WL_DISPLAY_READABLE); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 868 | |
| 869 | c->base.wl_display = display; |
| 870 | if (wayland_compositor_init_egl(c) < 0) |
Martin Olsson | c5db50f | 2012-07-08 03:03:43 +0200 | [diff] [blame] | 871 | goto err_display; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 872 | |
Benjamin Franzke | ecfb2b9 | 2011-01-15 12:34:48 +0100 | [diff] [blame] | 873 | c->base.destroy = wayland_destroy; |
Benjamin Franzke | ecfb2b9 | 2011-01-15 12:34:48 +0100 | [diff] [blame] | 874 | |
Daniel Stone | 725c2c3 | 2012-06-22 14:04:36 +0100 | [diff] [blame] | 875 | if (weston_compositor_init_gl(&c->base) < 0) |
Martin Olsson | c5db50f | 2012-07-08 03:03:43 +0200 | [diff] [blame] | 876 | goto err_display; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 877 | |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 878 | create_border(c); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 879 | if (wayland_compositor_create_output(c, width, height) < 0) |
Martin Olsson | c5db50f | 2012-07-08 03:03:43 +0200 | [diff] [blame] | 880 | goto err_display; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 881 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 882 | loop = wl_display_get_event_loop(c->base.wl_display); |
| 883 | |
Kristian Høgsberg | 362b672 | 2012-06-18 15:13:51 -0400 | [diff] [blame] | 884 | fd = wl_display_get_fd(c->parent.wl_display, update_event_mask, c); |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 885 | c->parent.wl_source = |
| 886 | wl_event_loop_add_fd(loop, fd, c->parent.event_mask, |
| 887 | wayland_compositor_handle_event, c); |
| 888 | if (c->parent.wl_source == NULL) |
Martin Olsson | c5db50f | 2012-07-08 03:03:43 +0200 | [diff] [blame] | 889 | goto err_display; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 890 | |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 891 | return &c->base; |
Martin Olsson | c5db50f | 2012-07-08 03:03:43 +0200 | [diff] [blame] | 892 | |
| 893 | err_display: |
| 894 | wl_display_disconnect(c->parent.wl_display); |
| 895 | err_compositor: |
| 896 | weston_compositor_shutdown(&c->base); |
| 897 | err_free: |
| 898 | free(c); |
| 899 | return NULL; |
Benjamin Franzke | ec2e642 | 2010-11-27 19:04:12 +0100 | [diff] [blame] | 900 | } |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 901 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 902 | WL_EXPORT struct weston_compositor * |
Daniel Stone | c1be8e5 | 2012-06-01 11:14:02 -0400 | [diff] [blame] | 903 | backend_init(struct wl_display *display, int argc, char *argv[], |
| 904 | const char *config_file) |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 905 | { |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 906 | int width = 1024, height = 640; |
| 907 | char *display_name = NULL; |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 908 | |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 909 | const struct weston_option wayland_options[] = { |
| 910 | { WESTON_OPTION_INTEGER, "width", 0, &width }, |
| 911 | { WESTON_OPTION_INTEGER, "height", 0, &height }, |
| 912 | { WESTON_OPTION_STRING, "display", 0, &display_name }, |
| 913 | }; |
| 914 | |
| 915 | parse_options(wayland_options, |
| 916 | ARRAY_LENGTH(wayland_options), argc, argv); |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 917 | |
Daniel Stone | baf4359 | 2012-06-01 11:11:10 -0400 | [diff] [blame] | 918 | return wayland_compositor_create(display, width, height, display_name, |
Daniel Stone | c1be8e5 | 2012-06-01 11:14:02 -0400 | [diff] [blame] | 919 | argc, argv, config_file); |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 920 | } |