Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 1 | /* |
Kristian Høgsberg | 96aa7da | 2011-09-15 15:43:14 -0400 | [diff] [blame] | 2 | * Copyright © 2008-2011 Kristian Høgsberg |
| 3 | * Copyright © 2010-2011 Intel Corporation |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 4 | * |
Kristian Høgsberg | 96aa7da | 2011-09-15 15:43:14 -0400 | [diff] [blame] | 5 | * Permission to use, copy, modify, distribute, and sell this software and |
| 6 | * its documentation for any purpose is hereby granted without fee, provided |
| 7 | * that the above copyright notice appear in all copies and that both that |
| 8 | * copyright notice and this permission notice appear in supporting |
| 9 | * documentation, and that the name of the copyright holders not be used in |
| 10 | * advertising or publicity pertaining to distribution of the software |
| 11 | * without specific, written prior permission. The copyright holders make |
| 12 | * no representations about the suitability of this software for any |
| 13 | * purpose. It is provided "as is" without express or implied warranty. |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 14 | * |
Kristian Høgsberg | 96aa7da | 2011-09-15 15:43:14 -0400 | [diff] [blame] | 15 | * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS |
| 16 | * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| 17 | * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| 18 | * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER |
| 19 | * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF |
| 20 | * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 21 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 22 | */ |
| 23 | |
Chia-I Wu | 1b6c0ed | 2010-10-29 15:20:18 +0800 | [diff] [blame] | 24 | #ifdef HAVE_CONFIG_H |
| 25 | #include <config.h> |
| 26 | #endif |
| 27 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 28 | #include <stddef.h> |
| 29 | #include <stdio.h> |
| 30 | #include <stdlib.h> |
| 31 | #include <string.h> |
| 32 | #include <fcntl.h> |
| 33 | #include <unistd.h> |
| 34 | #include <errno.h> |
| 35 | #include <sys/time.h> |
Kristian Høgsberg | f9112b2 | 2010-06-14 12:53:43 -0400 | [diff] [blame] | 36 | #include <linux/input.h> |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 37 | |
| 38 | #include <xcb/xcb.h> |
Benjamin Franzke | 3b288af | 2011-02-20 19:58:42 +0100 | [diff] [blame] | 39 | #include <X11/Xlib.h> |
| 40 | #include <X11/Xlib-xcb.h> |
| 41 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 42 | #include <GLES2/gl2.h> |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 43 | #include <EGL/egl.h> |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 44 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 45 | #include "compositor.h" |
| 46 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 47 | struct x11_compositor { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 48 | struct weston_compositor base; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 49 | |
Benjamin Franzke | 3b288af | 2011-02-20 19:58:42 +0100 | [diff] [blame] | 50 | Display *dpy; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 51 | xcb_connection_t *conn; |
| 52 | xcb_screen_t *screen; |
| 53 | xcb_cursor_t null_cursor; |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 54 | struct wl_array keys; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 55 | struct wl_event_source *xcb_source; |
| 56 | struct { |
| 57 | xcb_atom_t wm_protocols; |
| 58 | xcb_atom_t wm_normal_hints; |
| 59 | xcb_atom_t wm_size_hints; |
| 60 | xcb_atom_t wm_delete_window; |
Kristian Høgsberg | 24ed621 | 2011-01-26 14:02:31 -0500 | [diff] [blame] | 61 | xcb_atom_t wm_class; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 62 | xcb_atom_t net_wm_name; |
Kristian Høgsberg | f58d8ca | 2011-01-26 14:37:07 -0500 | [diff] [blame] | 63 | xcb_atom_t net_wm_icon; |
Kristian Høgsberg | 83eeacb | 2011-06-18 04:20:54 -0400 | [diff] [blame] | 64 | xcb_atom_t net_wm_state; |
| 65 | xcb_atom_t net_wm_state_fullscreen; |
Kristian Høgsberg | 24ed621 | 2011-01-26 14:02:31 -0500 | [diff] [blame] | 66 | xcb_atom_t string; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 67 | xcb_atom_t utf8_string; |
Kristian Høgsberg | f58d8ca | 2011-01-26 14:37:07 -0500 | [diff] [blame] | 68 | xcb_atom_t cardinal; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 69 | } atom; |
| 70 | }; |
| 71 | |
| 72 | struct x11_output { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 73 | struct weston_output base; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 74 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 75 | xcb_window_t window; |
Benjamin Franzke | 84290d0 | 2011-03-02 10:07:59 +0100 | [diff] [blame] | 76 | EGLSurface egl_surface; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 77 | struct weston_mode mode; |
Kristian Høgsberg | 06a670f | 2011-10-29 14:39:13 -0400 | [diff] [blame] | 78 | struct wl_event_source *finish_frame_timer; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 79 | }; |
| 80 | |
| 81 | struct x11_input { |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 82 | struct weston_input_device base; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 83 | }; |
| 84 | |
| 85 | |
Darxus | 55973f2 | 2010-11-22 21:24:39 -0500 | [diff] [blame] | 86 | static int |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 87 | x11_input_create(struct x11_compositor *c) |
| 88 | { |
| 89 | struct x11_input *input; |
| 90 | |
| 91 | input = malloc(sizeof *input); |
| 92 | if (input == NULL) |
Darxus | 55973f2 | 2010-11-22 21:24:39 -0500 | [diff] [blame] | 93 | return -1; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 94 | |
| 95 | memset(input, 0, sizeof *input); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 96 | weston_input_device_init(&input->base, &c->base); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 97 | |
Kristian Høgsberg | 9c3e8d7 | 2010-12-08 09:48:52 -0500 | [diff] [blame] | 98 | c->base.input_device = &input->base.input_device; |
Darxus | 55973f2 | 2010-11-22 21:24:39 -0500 | [diff] [blame] | 99 | |
| 100 | return 0; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 101 | } |
| 102 | |
Pekka Paalanen | 43c61d8 | 2012-01-03 11:58:34 +0200 | [diff] [blame] | 103 | static void |
| 104 | x11_input_destroy(struct x11_compositor *compositor) |
| 105 | { |
| 106 | struct x11_input *input = container_of(compositor->base.input_device, |
| 107 | struct x11_input, |
| 108 | base.input_device); |
| 109 | |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 110 | weston_input_device_release(&input->base); |
Pekka Paalanen | 43c61d8 | 2012-01-03 11:58:34 +0200 | [diff] [blame] | 111 | free(input); |
| 112 | } |
| 113 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 114 | static int |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 115 | x11_compositor_init_egl(struct x11_compositor *c) |
| 116 | { |
Kristian Høgsberg | 379b678 | 2010-07-28 22:52:28 -0400 | [diff] [blame] | 117 | EGLint major, minor; |
Benjamin Franzke | 84290d0 | 2011-03-02 10:07:59 +0100 | [diff] [blame] | 118 | EGLint n; |
Kristian Høgsberg | 379b678 | 2010-07-28 22:52:28 -0400 | [diff] [blame] | 119 | const char *extensions; |
Benjamin Franzke | 84290d0 | 2011-03-02 10:07:59 +0100 | [diff] [blame] | 120 | EGLint config_attribs[] = { |
| 121 | EGL_SURFACE_TYPE, EGL_WINDOW_BIT, |
| 122 | EGL_RED_SIZE, 1, |
| 123 | EGL_GREEN_SIZE, 1, |
| 124 | EGL_BLUE_SIZE, 1, |
| 125 | EGL_DEPTH_SIZE, 1, |
| 126 | EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
| 127 | EGL_NONE |
| 128 | }; |
Kristian Høgsberg | 2c28aa5 | 2010-07-28 23:47:54 -0400 | [diff] [blame] | 129 | static const EGLint context_attribs[] = { |
| 130 | EGL_CONTEXT_CLIENT_VERSION, 2, |
| 131 | EGL_NONE |
| 132 | }; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 133 | |
Benjamin Franzke | 3b288af | 2011-02-20 19:58:42 +0100 | [diff] [blame] | 134 | c->base.display = eglGetDisplay(c->dpy); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 135 | if (c->base.display == NULL) { |
| 136 | fprintf(stderr, "failed to create display\n"); |
| 137 | return -1; |
| 138 | } |
| 139 | |
| 140 | if (!eglInitialize(c->base.display, &major, &minor)) { |
| 141 | fprintf(stderr, "failed to initialize display\n"); |
| 142 | return -1; |
| 143 | } |
| 144 | |
Kristian Høgsberg | 379b678 | 2010-07-28 22:52:28 -0400 | [diff] [blame] | 145 | extensions = eglQueryString(c->base.display, EGL_EXTENSIONS); |
Ander Conselvan de Oliveira | ef7c8d9 | 2011-11-01 16:37:41 +0200 | [diff] [blame] | 146 | if (!strstr(extensions, "EGL_KHR_surfaceless_gles2")) { |
| 147 | fprintf(stderr, "EGL_KHR_surfaceless_gles2 not available\n"); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 148 | return -1; |
| 149 | } |
| 150 | |
Darxus | 55973f2 | 2010-11-22 21:24:39 -0500 | [diff] [blame] | 151 | if (!eglBindAPI(EGL_OPENGL_ES_API)) { |
| 152 | fprintf(stderr, "failed to bind EGL_OPENGL_ES_API\n"); |
| 153 | return -1; |
| 154 | } |
Benjamin Franzke | 84290d0 | 2011-03-02 10:07:59 +0100 | [diff] [blame] | 155 | if (!eglChooseConfig(c->base.display, config_attribs, |
| 156 | &c->base.config, 1, &n) || n == 0) { |
| 157 | fprintf(stderr, "failed to choose config: %d\n", n); |
| 158 | return -1; |
| 159 | } |
Darxus | 55973f2 | 2010-11-22 21:24:39 -0500 | [diff] [blame] | 160 | |
Benjamin Franzke | 84290d0 | 2011-03-02 10:07:59 +0100 | [diff] [blame] | 161 | c->base.context = eglCreateContext(c->base.display, c->base.config, |
Kristian Høgsberg | 2c28aa5 | 2010-07-28 23:47:54 -0400 | [diff] [blame] | 162 | EGL_NO_CONTEXT, context_attribs); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 163 | if (c->base.context == NULL) { |
| 164 | fprintf(stderr, "failed to create context\n"); |
| 165 | return -1; |
| 166 | } |
| 167 | |
| 168 | if (!eglMakeCurrent(c->base.display, EGL_NO_SURFACE, |
| 169 | EGL_NO_SURFACE, c->base.context)) { |
| 170 | fprintf(stderr, "failed to make context current\n"); |
| 171 | return -1; |
| 172 | } |
| 173 | |
| 174 | return 0; |
| 175 | } |
| 176 | |
Pekka Paalanen | 43c61d8 | 2012-01-03 11:58:34 +0200 | [diff] [blame] | 177 | static void |
| 178 | x11_compositor_fini_egl(struct x11_compositor *compositor) |
| 179 | { |
| 180 | eglMakeCurrent(compositor->base.display, |
| 181 | EGL_NO_SURFACE, EGL_NO_SURFACE, |
| 182 | EGL_NO_CONTEXT); |
| 183 | |
| 184 | eglTerminate(compositor->base.display); |
| 185 | eglReleaseThread(); |
| 186 | } |
| 187 | |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 188 | static int |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 189 | x11_output_prepare_render(struct weston_output *output_base) |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 190 | { |
| 191 | struct x11_output *output = (struct x11_output *) output_base; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 192 | struct weston_compositor *ec = output->base.compositor; |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 193 | |
| 194 | if (!eglMakeCurrent(ec->display, output->egl_surface, |
| 195 | output->egl_surface, ec->context)) { |
| 196 | fprintf(stderr, "failed to make current\n"); |
| 197 | return -1; |
| 198 | } |
| 199 | |
| 200 | return 0; |
| 201 | } |
| 202 | |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 203 | static int |
Kristian Høgsberg | 06a670f | 2011-10-29 14:39:13 -0400 | [diff] [blame] | 204 | finish_frame_handler(void *data) |
| 205 | { |
| 206 | struct x11_output *output = data; |
| 207 | uint32_t msec; |
| 208 | struct timeval tv; |
| 209 | |
| 210 | gettimeofday(&tv, NULL); |
| 211 | msec = tv.tv_sec * 1000 + tv.tv_usec / 1000; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 212 | weston_output_finish_frame(&output->base, msec); |
Kristian Høgsberg | 06a670f | 2011-10-29 14:39:13 -0400 | [diff] [blame] | 213 | |
| 214 | return 1; |
| 215 | } |
| 216 | |
| 217 | static int |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 218 | x11_output_present(struct weston_output *output_base) |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 219 | { |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 220 | struct x11_output *output = (struct x11_output *) output_base; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 221 | struct weston_compositor *ec = output->base.compositor; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 222 | |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 223 | if (x11_output_prepare_render(&output->base)) |
| 224 | return -1; |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 225 | |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 226 | eglSwapBuffers(ec->display, output->egl_surface); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 227 | |
Kristian Høgsberg | 06a670f | 2011-10-29 14:39:13 -0400 | [diff] [blame] | 228 | wl_event_source_timer_update(output->finish_frame_timer, 10); |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 229 | |
| 230 | return 0; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 231 | } |
| 232 | |
Benjamin Franzke | 1178a3c | 2011-04-10 16:49:52 +0200 | [diff] [blame] | 233 | static int |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 234 | x11_output_prepare_scanout_surface(struct weston_output *output_base, |
| 235 | struct weston_surface *es) |
Benjamin Franzke | 1178a3c | 2011-04-10 16:49:52 +0200 | [diff] [blame] | 236 | { |
Benjamin Franzke | 66aa235 | 2011-04-20 17:06:13 +0200 | [diff] [blame] | 237 | return -1; |
Benjamin Franzke | 1178a3c | 2011-04-10 16:49:52 +0200 | [diff] [blame] | 238 | } |
| 239 | |
Benjamin Franzke | 431da9a | 2011-04-20 11:02:58 +0200 | [diff] [blame] | 240 | static int |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 241 | x11_output_set_cursor(struct weston_output *output_base, |
| 242 | struct weston_input_device *input) |
Benjamin Franzke | 431da9a | 2011-04-20 11:02:58 +0200 | [diff] [blame] | 243 | { |
| 244 | return -1; |
| 245 | } |
| 246 | |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 247 | static void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 248 | x11_output_destroy(struct weston_output *output_base) |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 249 | { |
Pekka Paalanen | 2de99e2 | 2012-01-03 11:51:03 +0200 | [diff] [blame] | 250 | struct x11_output *output = (struct x11_output *)output_base; |
| 251 | struct x11_compositor *compositor = |
| 252 | (struct x11_compositor *)output->base.compositor; |
| 253 | |
| 254 | wl_list_remove(&output->base.link); |
| 255 | wl_event_source_remove(output->finish_frame_timer); |
| 256 | |
| 257 | eglDestroySurface(compositor->base.display, output->egl_surface); |
| 258 | |
| 259 | xcb_destroy_window(compositor->conn, output->window); |
| 260 | |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 261 | weston_output_destroy(&output->base); |
Pekka Paalanen | 2de99e2 | 2012-01-03 11:51:03 +0200 | [diff] [blame] | 262 | |
| 263 | free(output); |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 264 | } |
Benjamin Franzke | 431da9a | 2011-04-20 11:02:58 +0200 | [diff] [blame] | 265 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 266 | static void |
| 267 | x11_output_set_wm_protocols(struct x11_output *output) |
| 268 | { |
| 269 | xcb_atom_t list[1]; |
| 270 | struct x11_compositor *c = |
| 271 | (struct x11_compositor *) output->base.compositor; |
| 272 | |
| 273 | list[0] = c->atom.wm_delete_window; |
| 274 | xcb_change_property (c->conn, |
| 275 | XCB_PROP_MODE_REPLACE, |
| 276 | output->window, |
| 277 | c->atom.wm_protocols, |
| 278 | XCB_ATOM_ATOM, |
| 279 | 32, |
Kristian Høgsberg | 09e2692 | 2011-12-23 13:33:45 -0500 | [diff] [blame] | 280 | ARRAY_LENGTH(list), |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 281 | list); |
| 282 | } |
| 283 | |
Kristian Høgsberg | 83eeacb | 2011-06-18 04:20:54 -0400 | [diff] [blame] | 284 | static void |
| 285 | x11_output_change_state(struct x11_output *output, int add, xcb_atom_t state) |
| 286 | { |
| 287 | xcb_client_message_event_t event; |
| 288 | struct x11_compositor *c = |
| 289 | (struct x11_compositor *) output->base.compositor; |
| 290 | xcb_screen_iterator_t iter; |
| 291 | |
| 292 | #define _NET_WM_STATE_REMOVE 0 /* remove/unset property */ |
| 293 | #define _NET_WM_STATE_ADD 1 /* add/set property */ |
| 294 | #define _NET_WM_STATE_TOGGLE 2 /* toggle property */ |
| 295 | |
| 296 | memset(&event, 0, sizeof event); |
| 297 | event.response_type = XCB_CLIENT_MESSAGE; |
| 298 | event.format = 32; |
| 299 | event.window = output->window; |
| 300 | event.type = c->atom.net_wm_state; |
| 301 | |
| 302 | event.data.data32[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE; |
| 303 | event.data.data32[1] = state; |
| 304 | event.data.data32[2] = 0; |
| 305 | event.data.data32[3] = 0; |
| 306 | event.data.data32[4] = 0; |
| 307 | |
| 308 | iter = xcb_setup_roots_iterator(xcb_get_setup(c->conn)); |
| 309 | xcb_send_event(c->conn, 0, iter.data->root, |
| 310 | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | |
| 311 | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, |
| 312 | (void *) &event); |
| 313 | } |
| 314 | |
| 315 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 316 | struct wm_normal_hints { |
| 317 | uint32_t flags; |
| 318 | uint32_t pad[4]; |
| 319 | int32_t min_width, min_height; |
| 320 | int32_t max_width, max_height; |
| 321 | int32_t width_inc, height_inc; |
| 322 | int32_t min_aspect_x, min_aspect_y; |
| 323 | int32_t max_aspect_x, max_aspect_y; |
| 324 | int32_t base_width, base_height; |
| 325 | int32_t win_gravity; |
| 326 | }; |
| 327 | |
| 328 | #define WM_NORMAL_HINTS_MIN_SIZE 16 |
| 329 | #define WM_NORMAL_HINTS_MAX_SIZE 32 |
| 330 | |
Kristian Høgsberg | f58d8ca | 2011-01-26 14:37:07 -0500 | [diff] [blame] | 331 | static void |
Kristian Høgsberg | b41d76c | 2011-04-23 15:03:15 -0400 | [diff] [blame] | 332 | x11_output_set_icon(struct x11_compositor *c, |
| 333 | struct x11_output *output, const char *filename) |
Kristian Høgsberg | f58d8ca | 2011-01-26 14:37:07 -0500 | [diff] [blame] | 334 | { |
Kristian Høgsberg | b41d76c | 2011-04-23 15:03:15 -0400 | [diff] [blame] | 335 | uint32_t *icon, *pixels, stride; |
| 336 | int32_t width, height; |
Kristian Høgsberg | f58d8ca | 2011-01-26 14:37:07 -0500 | [diff] [blame] | 337 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 338 | pixels = weston_load_image(filename, &width, &height, &stride); |
Kristian Høgsberg | f58d8ca | 2011-01-26 14:37:07 -0500 | [diff] [blame] | 339 | if (!pixels) |
| 340 | return; |
| 341 | icon = malloc(width * height * 4 + 8); |
| 342 | if (!icon) { |
| 343 | free(pixels); |
| 344 | return; |
| 345 | } |
| 346 | |
| 347 | icon[0] = width; |
| 348 | icon[1] = height; |
| 349 | memcpy(icon + 2, pixels, width * height * 4); |
| 350 | xcb_change_property(c->conn, XCB_PROP_MODE_REPLACE, output->window, |
| 351 | c->atom.net_wm_icon, c->atom.cardinal, 32, |
| 352 | width * height + 2, icon); |
| 353 | free(icon); |
| 354 | free(pixels); |
| 355 | } |
| 356 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 357 | static int |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 358 | x11_compositor_create_output(struct x11_compositor *c, int x, int y, |
Kristian Høgsberg | 83eeacb | 2011-06-18 04:20:54 -0400 | [diff] [blame] | 359 | int width, int height, int fullscreen) |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 360 | { |
| 361 | static const char name[] = "Wayland Compositor"; |
Kristian Høgsberg | 24ed621 | 2011-01-26 14:02:31 -0500 | [diff] [blame] | 362 | static const char class[] = "wayland-1\0Wayland Compositor"; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 363 | struct x11_output *output; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 364 | xcb_screen_iterator_t iter; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 365 | struct wm_normal_hints normal_hints; |
Kristian Høgsberg | 06a670f | 2011-10-29 14:39:13 -0400 | [diff] [blame] | 366 | struct wl_event_loop *loop; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 367 | uint32_t mask = XCB_CW_EVENT_MASK | XCB_CW_CURSOR; |
| 368 | uint32_t values[2] = { |
| 369 | XCB_EVENT_MASK_KEY_PRESS | |
| 370 | XCB_EVENT_MASK_KEY_RELEASE | |
| 371 | XCB_EVENT_MASK_BUTTON_PRESS | |
| 372 | XCB_EVENT_MASK_BUTTON_RELEASE | |
| 373 | XCB_EVENT_MASK_POINTER_MOTION | |
| 374 | XCB_EVENT_MASK_EXPOSURE | |
Kristian Høgsberg | 86e0989 | 2010-07-07 09:51:11 -0400 | [diff] [blame] | 375 | XCB_EVENT_MASK_STRUCTURE_NOTIFY | |
| 376 | XCB_EVENT_MASK_ENTER_WINDOW | |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 377 | XCB_EVENT_MASK_LEAVE_WINDOW | |
| 378 | XCB_EVENT_MASK_KEYMAP_STATE | |
| 379 | XCB_EVENT_MASK_FOCUS_CHANGE, |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 380 | 0 |
| 381 | }; |
| 382 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 383 | output = malloc(sizeof *output); |
| 384 | if (output == NULL) |
| 385 | return -1; |
| 386 | |
| 387 | memset(output, 0, sizeof *output); |
Kristian Høgsberg | 8f0ce05 | 2011-06-21 11:16:58 -0400 | [diff] [blame] | 388 | |
| 389 | output->mode.flags = |
| 390 | WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED; |
| 391 | output->mode.width = width; |
| 392 | output->mode.height = height; |
| 393 | output->mode.refresh = 60; |
| 394 | wl_list_init(&output->base.mode_list); |
| 395 | wl_list_insert(&output->base.mode_list, &output->mode.link); |
| 396 | |
| 397 | output->base.current = &output->mode; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 398 | weston_output_init(&output->base, &c->base, x, y, width, height, |
Benjamin Franzke | 84290d0 | 2011-03-02 10:07:59 +0100 | [diff] [blame] | 399 | WL_OUTPUT_FLIPPED); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 400 | |
| 401 | values[1] = c->null_cursor; |
| 402 | output->window = xcb_generate_id(c->conn); |
| 403 | iter = xcb_setup_roots_iterator(xcb_get_setup(c->conn)); |
| 404 | xcb_create_window(c->conn, |
| 405 | XCB_COPY_FROM_PARENT, |
| 406 | output->window, |
| 407 | iter.data->root, |
| 408 | 0, 0, |
| 409 | width, height, |
| 410 | 0, |
| 411 | XCB_WINDOW_CLASS_INPUT_OUTPUT, |
| 412 | iter.data->root_visual, |
| 413 | mask, values); |
| 414 | |
| 415 | /* Don't resize me. */ |
| 416 | memset(&normal_hints, 0, sizeof normal_hints); |
| 417 | normal_hints.flags = |
| 418 | WM_NORMAL_HINTS_MAX_SIZE | WM_NORMAL_HINTS_MIN_SIZE; |
| 419 | normal_hints.min_width = width; |
| 420 | normal_hints.min_height = height; |
| 421 | normal_hints.max_width = width; |
| 422 | normal_hints.max_height = height; |
| 423 | xcb_change_property (c->conn, XCB_PROP_MODE_REPLACE, output->window, |
| 424 | c->atom.wm_normal_hints, |
| 425 | c->atom.wm_size_hints, 32, |
| 426 | sizeof normal_hints / 4, |
| 427 | (uint8_t *) &normal_hints); |
| 428 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 429 | /* Set window name. Don't bother with non-EWMH WMs. */ |
| 430 | xcb_change_property(c->conn, XCB_PROP_MODE_REPLACE, output->window, |
| 431 | c->atom.net_wm_name, c->atom.utf8_string, 8, |
| 432 | strlen(name), name); |
Kristian Høgsberg | 24ed621 | 2011-01-26 14:02:31 -0500 | [diff] [blame] | 433 | xcb_change_property(c->conn, XCB_PROP_MODE_REPLACE, output->window, |
| 434 | c->atom.wm_class, c->atom.string, 8, |
| 435 | sizeof class, class); |
| 436 | |
Kristian Høgsberg | b41d76c | 2011-04-23 15:03:15 -0400 | [diff] [blame] | 437 | x11_output_set_icon(c, output, DATADIR "/wayland/wayland.png"); |
Kristian Høgsberg | f58d8ca | 2011-01-26 14:37:07 -0500 | [diff] [blame] | 438 | |
Kristian Høgsberg | 24ed621 | 2011-01-26 14:02:31 -0500 | [diff] [blame] | 439 | xcb_map_window(c->conn, output->window); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 440 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 441 | x11_output_set_wm_protocols(output); |
| 442 | |
Kristian Høgsberg | 83eeacb | 2011-06-18 04:20:54 -0400 | [diff] [blame] | 443 | if (fullscreen) |
| 444 | x11_output_change_state(output, 1, |
| 445 | c->atom.net_wm_state_fullscreen); |
| 446 | |
Benjamin Franzke | 84290d0 | 2011-03-02 10:07:59 +0100 | [diff] [blame] | 447 | output->egl_surface = |
| 448 | eglCreateWindowSurface(c->base.display, c->base.config, |
| 449 | output->window, NULL); |
| 450 | if (!output->egl_surface) { |
| 451 | fprintf(stderr, "failed to create window surface\n"); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 452 | return -1; |
| 453 | } |
Benjamin Franzke | 84290d0 | 2011-03-02 10:07:59 +0100 | [diff] [blame] | 454 | if (!eglMakeCurrent(c->base.display, output->egl_surface, |
| 455 | output->egl_surface, c->base.context)) { |
| 456 | fprintf(stderr, "failed to make surface current\n"); |
| 457 | return -1; |
| 458 | } |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 459 | |
Kristian Høgsberg | 06a670f | 2011-10-29 14:39:13 -0400 | [diff] [blame] | 460 | loop = wl_display_get_event_loop(c->base.wl_display); |
| 461 | output->finish_frame_timer = |
| 462 | wl_event_loop_add_timer(loop, finish_frame_handler, output); |
| 463 | |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 464 | output->base.prepare_render = x11_output_prepare_render; |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 465 | output->base.present = x11_output_present; |
Benjamin Franzke | 66aa235 | 2011-04-20 17:06:13 +0200 | [diff] [blame] | 466 | output->base.prepare_scanout_surface = |
| 467 | x11_output_prepare_scanout_surface; |
Benjamin Franzke | 431da9a | 2011-04-20 11:02:58 +0200 | [diff] [blame] | 468 | output->base.set_hardware_cursor = x11_output_set_cursor; |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 469 | output->base.destroy = x11_output_destroy; |
Benjamin Franzke | eefc36c | 2011-03-11 16:39:20 +0100 | [diff] [blame] | 470 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 471 | wl_list_insert(c->base.output_list.prev, &output->base.link); |
| 472 | |
| 473 | return 0; |
| 474 | } |
| 475 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 476 | static struct x11_output * |
| 477 | x11_compositor_find_output(struct x11_compositor *c, xcb_window_t window) |
| 478 | { |
| 479 | struct x11_output *output; |
| 480 | |
| 481 | wl_list_for_each(output, &c->base.output_list, base.link) { |
| 482 | if (output->window == window) |
| 483 | return output; |
| 484 | } |
| 485 | |
| 486 | return NULL; |
| 487 | } |
| 488 | |
Tiago Vignatti | a3a7162 | 2011-12-08 17:03:17 +0200 | [diff] [blame] | 489 | static void |
| 490 | x11_compositor_deliver_button_event(struct x11_compositor *c, |
| 491 | xcb_generic_event_t *event, int state) |
| 492 | { |
| 493 | xcb_button_press_event_t *button_event = |
| 494 | (xcb_button_press_event_t *) event; |
| 495 | int button; |
| 496 | |
| 497 | switch (button_event->detail) { |
| 498 | default: |
| 499 | button = button_event->detail + BTN_LEFT - 1; |
| 500 | break; |
| 501 | case 2: |
| 502 | button = BTN_MIDDLE; |
| 503 | break; |
| 504 | case 3: |
| 505 | button = BTN_RIGHT; |
| 506 | break; |
| 507 | case 4: |
| 508 | case 5: |
| 509 | case 6: |
| 510 | case 7: |
| 511 | /* X11 sends wheel events as buttons events. But |
| 512 | * linux input treats as REL_WHEEL, therefore not |
| 513 | * button type at all. When we update the input |
| 514 | * protocol and get the 'axis' event, we'll send |
| 515 | * scroll events as axis events. */ |
| 516 | return; |
| 517 | } |
| 518 | |
| 519 | notify_button(c->base.input_device, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 520 | weston_compositor_get_time(), button, state); |
Tiago Vignatti | a3a7162 | 2011-12-08 17:03:17 +0200 | [diff] [blame] | 521 | } |
| 522 | |
Kristian Høgsberg | ee72482 | 2011-04-21 14:51:44 -0400 | [diff] [blame] | 523 | static int |
| 524 | x11_compositor_next_event(struct x11_compositor *c, |
Kristian Høgsberg | 127d0f0 | 2011-04-22 12:18:13 -0400 | [diff] [blame] | 525 | xcb_generic_event_t **event, uint32_t mask) |
Kristian Høgsberg | ee72482 | 2011-04-21 14:51:44 -0400 | [diff] [blame] | 526 | { |
Kristian Høgsberg | 127d0f0 | 2011-04-22 12:18:13 -0400 | [diff] [blame] | 527 | if (mask & WL_EVENT_READABLE) { |
| 528 | *event = xcb_poll_for_event(c->conn); |
Kristian Høgsberg | ee72482 | 2011-04-21 14:51:44 -0400 | [diff] [blame] | 529 | } else { |
Kristian Høgsberg | 82ed042 | 2011-04-25 15:41:59 -0400 | [diff] [blame] | 530 | #ifdef HAVE_XCB_POLL_FOR_QUEUED_EVENT |
Kristian Høgsberg | 127d0f0 | 2011-04-22 12:18:13 -0400 | [diff] [blame] | 531 | *event = xcb_poll_for_queued_event(c->conn); |
Kristian Høgsberg | 82ed042 | 2011-04-25 15:41:59 -0400 | [diff] [blame] | 532 | #else |
| 533 | *event = xcb_poll_for_event(c->conn); |
| 534 | #endif |
Kristian Høgsberg | ee72482 | 2011-04-21 14:51:44 -0400 | [diff] [blame] | 535 | } |
| 536 | |
| 537 | return *event != NULL; |
| 538 | } |
| 539 | |
Kristian Høgsberg | 127d0f0 | 2011-04-22 12:18:13 -0400 | [diff] [blame] | 540 | static int |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 541 | x11_compositor_handle_event(int fd, uint32_t mask, void *data) |
| 542 | { |
| 543 | struct x11_compositor *c = data; |
| 544 | struct x11_output *output; |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 545 | xcb_generic_event_t *event, *prev; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 546 | xcb_client_message_event_t *client_message; |
| 547 | xcb_motion_notify_event_t *motion_notify; |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 548 | xcb_enter_notify_event_t *enter_notify; |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 549 | xcb_key_press_event_t *key_press, *key_release; |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 550 | xcb_keymap_notify_event_t *keymap_notify; |
| 551 | xcb_focus_in_event_t *focus_in; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 552 | xcb_atom_t atom; |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 553 | uint32_t *k; |
| 554 | int i, set; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 555 | |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 556 | prev = NULL; |
Kristian Høgsberg | 127d0f0 | 2011-04-22 12:18:13 -0400 | [diff] [blame] | 557 | while (x11_compositor_next_event(c, &event, mask)) { |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 558 | switch (prev ? prev->response_type & ~0x80 : 0x80) { |
| 559 | case XCB_KEY_RELEASE: |
| 560 | key_release = (xcb_key_press_event_t *) prev; |
| 561 | key_press = (xcb_key_press_event_t *) event; |
| 562 | if ((event->response_type & ~0x80) == XCB_KEY_PRESS && |
Dima Ryazanov | c224748 | 2011-08-16 17:25:32 -0700 | [diff] [blame] | 563 | key_release->time == key_press->time && |
| 564 | key_release->detail == key_press->detail) { |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 565 | /* Don't deliver the held key release |
| 566 | * event or the new key press event. */ |
| 567 | free(event); |
| 568 | free(prev); |
| 569 | prev = NULL; |
| 570 | continue; |
| 571 | } else { |
| 572 | /* Deliver the held key release now |
| 573 | * and fall through and handle the new |
Kristian Høgsberg | 025f7b8 | 2011-04-19 12:38:22 -0400 | [diff] [blame] | 574 | * event below. */ |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 575 | notify_key(c->base.input_device, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 576 | weston_compositor_get_time(), |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 577 | key_release->detail - 8, 0); |
| 578 | free(prev); |
| 579 | prev = NULL; |
| 580 | break; |
| 581 | } |
Kristian Høgsberg | 025f7b8 | 2011-04-19 12:38:22 -0400 | [diff] [blame] | 582 | |
| 583 | case XCB_FOCUS_IN: |
Kristian Høgsberg | 025f7b8 | 2011-04-19 12:38:22 -0400 | [diff] [blame] | 584 | /* assert event is keymap_notify */ |
| 585 | focus_in = (xcb_focus_in_event_t *) prev; |
| 586 | keymap_notify = (xcb_keymap_notify_event_t *) event; |
| 587 | c->keys.size = 0; |
| 588 | for (i = 0; i < ARRAY_LENGTH(keymap_notify->keys) * 8; i++) { |
| 589 | set = keymap_notify->keys[i >> 3] & |
| 590 | (1 << (i & 7)); |
| 591 | if (set) { |
| 592 | k = wl_array_add(&c->keys, sizeof *k); |
| 593 | *k = i; |
| 594 | } |
| 595 | } |
| 596 | |
| 597 | output = x11_compositor_find_output(c, focus_in->event); |
| 598 | notify_keyboard_focus(c->base.input_device, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 599 | weston_compositor_get_time(), |
Kristian Høgsberg | 025f7b8 | 2011-04-19 12:38:22 -0400 | [diff] [blame] | 600 | &output->base, &c->keys); |
| 601 | |
| 602 | free(prev); |
| 603 | prev = NULL; |
| 604 | break; |
| 605 | |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 606 | default: |
| 607 | /* No previous event held */ |
| 608 | break; |
Kristian Høgsberg | 3ddd148 | 2011-04-15 15:48:07 -0400 | [diff] [blame] | 609 | } |
| 610 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 611 | switch (event->response_type & ~0x80) { |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 612 | case XCB_KEY_PRESS: |
| 613 | key_press = (xcb_key_press_event_t *) event; |
| 614 | notify_key(c->base.input_device, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 615 | weston_compositor_get_time(), |
Kristian Høgsberg | 293af26 | 2011-10-11 17:23:02 -0400 | [diff] [blame] | 616 | key_press->detail - 8, 1); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 617 | break; |
| 618 | case XCB_KEY_RELEASE: |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 619 | prev = event; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 620 | break; |
| 621 | case XCB_BUTTON_PRESS: |
Tiago Vignatti | a3a7162 | 2011-12-08 17:03:17 +0200 | [diff] [blame] | 622 | x11_compositor_deliver_button_event(c, event, 1); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 623 | break; |
| 624 | case XCB_BUTTON_RELEASE: |
Tiago Vignatti | a3a7162 | 2011-12-08 17:03:17 +0200 | [diff] [blame] | 625 | x11_compositor_deliver_button_event(c, event, 0); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 626 | break; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 627 | case XCB_MOTION_NOTIFY: |
| 628 | motion_notify = (xcb_motion_notify_event_t *) event; |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 629 | output = x11_compositor_find_output(c, motion_notify->event); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 630 | notify_motion(c->base.input_device, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 631 | weston_compositor_get_time(), |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 632 | output->base.x + motion_notify->event_x, |
| 633 | output->base.y + motion_notify->event_y); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 634 | break; |
| 635 | |
| 636 | case XCB_EXPOSE: |
Benjamin Franzke | 84290d0 | 2011-03-02 10:07:59 +0100 | [diff] [blame] | 637 | /* FIXME: schedule output repaint */ |
| 638 | /* output = x11_compositor_find_output(c, expose->window); */ |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 639 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 640 | weston_compositor_schedule_repaint(&c->base); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 641 | break; |
Kristian Høgsberg | 86e0989 | 2010-07-07 09:51:11 -0400 | [diff] [blame] | 642 | |
| 643 | case XCB_ENTER_NOTIFY: |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 644 | enter_notify = (xcb_enter_notify_event_t *) event; |
Kristian Høgsberg | 2dfe626 | 2011-02-08 11:59:53 -0500 | [diff] [blame] | 645 | if (enter_notify->state >= Button1Mask) |
| 646 | break; |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 647 | output = x11_compositor_find_output(c, enter_notify->event); |
| 648 | notify_pointer_focus(c->base.input_device, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 649 | weston_compositor_get_time(), |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 650 | &output->base, |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 651 | output->base.x + enter_notify->event_x, |
| 652 | output->base.y + enter_notify->event_y); |
Kristian Høgsberg | 86e0989 | 2010-07-07 09:51:11 -0400 | [diff] [blame] | 653 | break; |
| 654 | |
| 655 | case XCB_LEAVE_NOTIFY: |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 656 | enter_notify = (xcb_enter_notify_event_t *) event; |
Kristian Høgsberg | 2dfe626 | 2011-02-08 11:59:53 -0500 | [diff] [blame] | 657 | if (enter_notify->state >= Button1Mask) |
| 658 | break; |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 659 | output = x11_compositor_find_output(c, enter_notify->event); |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 660 | notify_pointer_focus(c->base.input_device, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 661 | weston_compositor_get_time(), |
Kristian Høgsberg | 93331ff | 2011-01-26 20:35:07 -0500 | [diff] [blame] | 662 | NULL, |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 663 | output->base.x + enter_notify->event_x, |
| 664 | output->base.y + enter_notify->event_y); |
Kristian Høgsberg | 86e0989 | 2010-07-07 09:51:11 -0400 | [diff] [blame] | 665 | break; |
| 666 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 667 | case XCB_CLIENT_MESSAGE: |
| 668 | client_message = (xcb_client_message_event_t *) event; |
| 669 | atom = client_message->data.data32[0]; |
| 670 | if (atom == c->atom.wm_delete_window) |
Kristian Høgsberg | 50dc698 | 2010-12-01 16:43:56 -0500 | [diff] [blame] | 671 | wl_display_terminate(c->base.wl_display); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 672 | break; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 673 | |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 674 | case XCB_FOCUS_IN: |
| 675 | focus_in = (xcb_focus_in_event_t *) event; |
| 676 | if (focus_in->mode == XCB_NOTIFY_MODE_WHILE_GRABBED) |
| 677 | break; |
| 678 | |
Kristian Høgsberg | 025f7b8 | 2011-04-19 12:38:22 -0400 | [diff] [blame] | 679 | prev = event; |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 680 | break; |
| 681 | |
| 682 | case XCB_FOCUS_OUT: |
| 683 | focus_in = (xcb_focus_in_event_t *) event; |
Kristian Høgsberg | 42e40ae | 2011-12-19 14:36:50 -0500 | [diff] [blame] | 684 | if (focus_in->mode == XCB_NOTIFY_MODE_WHILE_GRABBED || |
| 685 | focus_in->mode == XCB_NOTIFY_MODE_UNGRAB) |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 686 | break; |
| 687 | notify_keyboard_focus(c->base.input_device, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 688 | weston_compositor_get_time(), |
Kristian Høgsberg | 02ec0a5 | 2011-04-23 13:04:11 -0400 | [diff] [blame] | 689 | NULL, NULL); |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 690 | break; |
| 691 | |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 692 | default: |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 693 | break; |
| 694 | } |
| 695 | |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 696 | if (prev != event) |
Kristian Høgsberg | 3ddd148 | 2011-04-15 15:48:07 -0400 | [diff] [blame] | 697 | free (event); |
| 698 | } |
| 699 | |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 700 | switch (prev ? prev->response_type & ~0x80 : 0x80) { |
| 701 | case XCB_KEY_RELEASE: |
| 702 | key_release = (xcb_key_press_event_t *) prev; |
Kristian Høgsberg | 3ddd148 | 2011-04-15 15:48:07 -0400 | [diff] [blame] | 703 | notify_key(c->base.input_device, |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 704 | weston_compositor_get_time(), |
Kristian Høgsberg | 293af26 | 2011-10-11 17:23:02 -0400 | [diff] [blame] | 705 | key_release->detail - 8, 0); |
Kristian Høgsberg | 94da7e1 | 2011-04-19 09:23:29 -0400 | [diff] [blame] | 706 | free(prev); |
| 707 | prev = NULL; |
| 708 | break; |
| 709 | default: |
| 710 | break; |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 711 | } |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 712 | |
Kristian Høgsberg | 127d0f0 | 2011-04-22 12:18:13 -0400 | [diff] [blame] | 713 | return event != NULL; |
Kristian Høgsberg | ee72482 | 2011-04-21 14:51:44 -0400 | [diff] [blame] | 714 | } |
| 715 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 716 | #define F(field) offsetof(struct x11_compositor, field) |
| 717 | |
| 718 | static void |
| 719 | x11_compositor_get_resources(struct x11_compositor *c) |
| 720 | { |
| 721 | static const struct { const char *name; int offset; } atoms[] = { |
| 722 | { "WM_PROTOCOLS", F(atom.wm_protocols) }, |
| 723 | { "WM_NORMAL_HINTS", F(atom.wm_normal_hints) }, |
| 724 | { "WM_SIZE_HINTS", F(atom.wm_size_hints) }, |
| 725 | { "WM_DELETE_WINDOW", F(atom.wm_delete_window) }, |
Kristian Høgsberg | 24ed621 | 2011-01-26 14:02:31 -0500 | [diff] [blame] | 726 | { "WM_CLASS", F(atom.wm_class) }, |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 727 | { "_NET_WM_NAME", F(atom.net_wm_name) }, |
Kristian Høgsberg | f58d8ca | 2011-01-26 14:37:07 -0500 | [diff] [blame] | 728 | { "_NET_WM_ICON", F(atom.net_wm_icon) }, |
Kristian Høgsberg | 83eeacb | 2011-06-18 04:20:54 -0400 | [diff] [blame] | 729 | { "_NET_WM_STATE", F(atom.net_wm_state) }, |
| 730 | { "_NET_WM_STATE_FULLSCREEN", F(atom.net_wm_state_fullscreen) }, |
Kristian Høgsberg | 24ed621 | 2011-01-26 14:02:31 -0500 | [diff] [blame] | 731 | { "STRING", F(atom.string) }, |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 732 | { "UTF8_STRING", F(atom.utf8_string) }, |
Kristian Høgsberg | f58d8ca | 2011-01-26 14:37:07 -0500 | [diff] [blame] | 733 | { "CARDINAL", F(atom.cardinal) }, |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 734 | }; |
| 735 | |
Kristian Høgsberg | 09e2692 | 2011-12-23 13:33:45 -0500 | [diff] [blame] | 736 | xcb_intern_atom_cookie_t cookies[ARRAY_LENGTH(atoms)]; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 737 | xcb_intern_atom_reply_t *reply; |
| 738 | xcb_pixmap_t pixmap; |
| 739 | xcb_gc_t gc; |
| 740 | int i; |
| 741 | uint8_t data[] = { 0, 0, 0, 0 }; |
| 742 | |
Kristian Høgsberg | 09e2692 | 2011-12-23 13:33:45 -0500 | [diff] [blame] | 743 | for (i = 0; i < ARRAY_LENGTH(atoms); i++) |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 744 | cookies[i] = xcb_intern_atom (c->conn, 0, |
| 745 | strlen(atoms[i].name), |
| 746 | atoms[i].name); |
| 747 | |
Kristian Høgsberg | 09e2692 | 2011-12-23 13:33:45 -0500 | [diff] [blame] | 748 | for (i = 0; i < ARRAY_LENGTH(atoms); i++) { |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 749 | reply = xcb_intern_atom_reply (c->conn, cookies[i], NULL); |
| 750 | *(xcb_atom_t *) ((char *) c + atoms[i].offset) = reply->atom; |
| 751 | free(reply); |
| 752 | } |
| 753 | |
| 754 | pixmap = xcb_generate_id(c->conn); |
| 755 | gc = xcb_generate_id(c->conn); |
| 756 | xcb_create_pixmap(c->conn, 1, pixmap, c->screen->root, 1, 1); |
| 757 | xcb_create_gc(c->conn, gc, pixmap, 0, NULL); |
| 758 | xcb_put_image(c->conn, XCB_IMAGE_FORMAT_XY_PIXMAP, |
| 759 | pixmap, gc, 1, 1, 0, 0, 0, 32, sizeof data, data); |
| 760 | c->null_cursor = xcb_generate_id(c->conn); |
| 761 | xcb_create_cursor (c->conn, c->null_cursor, |
| 762 | pixmap, pixmap, 0, 0, 0, 0, 0, 0, 1, 1); |
| 763 | xcb_free_gc(c->conn, gc); |
| 764 | xcb_free_pixmap(c->conn, pixmap); |
| 765 | } |
| 766 | |
Kristian Høgsberg | caa6442 | 2010-12-01 16:52:15 -0500 | [diff] [blame] | 767 | static void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 768 | x11_destroy(struct weston_compositor *ec) |
Kristian Høgsberg | caa6442 | 2010-12-01 16:52:15 -0500 | [diff] [blame] | 769 | { |
Pekka Paalanen | 43c61d8 | 2012-01-03 11:58:34 +0200 | [diff] [blame] | 770 | struct x11_compositor *compositor = (struct x11_compositor *)ec; |
Matt Roper | 361d2ad | 2011-08-29 13:52:23 -0700 | [diff] [blame] | 771 | |
Pekka Paalanen | 43c61d8 | 2012-01-03 11:58:34 +0200 | [diff] [blame] | 772 | wl_event_source_remove(compositor->xcb_source); |
| 773 | x11_input_destroy(compositor); |
| 774 | |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 775 | weston_compositor_shutdown(ec); /* destroys outputs, too */ |
Pekka Paalanen | 43c61d8 | 2012-01-03 11:58:34 +0200 | [diff] [blame] | 776 | |
| 777 | x11_compositor_fini_egl(compositor); |
| 778 | |
| 779 | XCloseDisplay(compositor->dpy); |
Kristian Høgsberg | caa6442 | 2010-12-01 16:52:15 -0500 | [diff] [blame] | 780 | free(ec); |
| 781 | } |
| 782 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 783 | static struct weston_compositor * |
Kristian Høgsberg | 83eeacb | 2011-06-18 04:20:54 -0400 | [diff] [blame] | 784 | x11_compositor_create(struct wl_display *display, |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 785 | int width, int height, int count, int fullscreen) |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 786 | { |
| 787 | struct x11_compositor *c; |
| 788 | struct wl_event_loop *loop; |
| 789 | xcb_screen_iterator_t s; |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 790 | int i, x; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 791 | |
| 792 | c = malloc(sizeof *c); |
| 793 | if (c == NULL) |
| 794 | return NULL; |
| 795 | |
| 796 | memset(c, 0, sizeof *c); |
Benjamin Franzke | 3b288af | 2011-02-20 19:58:42 +0100 | [diff] [blame] | 797 | |
| 798 | c->dpy = XOpenDisplay(NULL); |
Cyril Brulebois | 2079829 | 2011-04-06 18:05:40 +0200 | [diff] [blame] | 799 | if (c->dpy == NULL) |
| 800 | return NULL; |
| 801 | |
Benjamin Franzke | 3b288af | 2011-02-20 19:58:42 +0100 | [diff] [blame] | 802 | c->conn = XGetXCBConnection(c->dpy); |
Benjamin Franzke | e997c5f | 2011-03-25 14:06:37 +0100 | [diff] [blame] | 803 | XSetEventQueueOwner(c->dpy, XCBOwnsEventQueue); |
| 804 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 805 | if (xcb_connection_has_error(c->conn)) |
| 806 | return NULL; |
| 807 | |
| 808 | s = xcb_setup_roots_iterator(xcb_get_setup(c->conn)); |
| 809 | c->screen = s.data; |
Kristian Høgsberg | 3ba4858 | 2011-01-27 11:57:19 -0500 | [diff] [blame] | 810 | wl_array_init(&c->keys); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 811 | |
| 812 | x11_compositor_get_resources(c); |
| 813 | |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 814 | c->base.wl_display = display; |
Tiago Vignatti | 997ce64 | 2010-11-10 02:42:35 +0200 | [diff] [blame] | 815 | if (x11_compositor_init_egl(c) < 0) |
Darxus | 55973f2 | 2010-11-22 21:24:39 -0500 | [diff] [blame] | 816 | return NULL; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 817 | |
Kristian Høgsberg | 8525a50 | 2011-01-14 16:20:21 -0500 | [diff] [blame] | 818 | c->base.destroy = x11_destroy; |
Kristian Høgsberg | 8525a50 | 2011-01-14 16:20:21 -0500 | [diff] [blame] | 819 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 820 | /* Can't init base class until we have a current egl context */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 821 | if (weston_compositor_init(&c->base, display) < 0) |
Kristian Høgsberg | a946821 | 2010-06-14 21:03:11 -0400 | [diff] [blame] | 822 | return NULL; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 823 | |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 824 | for (i = 0, x = 0; i < count; i++) { |
| 825 | if (x11_compositor_create_output(c, x, 0, width, height, |
| 826 | fullscreen) < 0) |
| 827 | return NULL; |
| 828 | x += width; |
| 829 | } |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 830 | |
Darxus | 55973f2 | 2010-11-22 21:24:39 -0500 | [diff] [blame] | 831 | if (x11_input_create(c) < 0) |
| 832 | return NULL; |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 833 | |
| 834 | loop = wl_display_get_event_loop(c->base.wl_display); |
| 835 | |
| 836 | c->xcb_source = |
| 837 | wl_event_loop_add_fd(loop, xcb_get_file_descriptor(c->conn), |
| 838 | WL_EVENT_READABLE, |
| 839 | x11_compositor_handle_event, c); |
Kristian Høgsberg | 127d0f0 | 2011-04-22 12:18:13 -0400 | [diff] [blame] | 840 | wl_event_source_check(c->xcb_source); |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 841 | |
Kristian Høgsberg | ce5325d | 2010-06-14 11:54:00 -0400 | [diff] [blame] | 842 | return &c->base; |
| 843 | } |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 844 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 845 | struct weston_compositor * |
Kristian Høgsberg | 6c709a3 | 2011-05-06 14:52:41 -0400 | [diff] [blame] | 846 | backend_init(struct wl_display *display, char *options); |
| 847 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 848 | WL_EXPORT struct weston_compositor * |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 849 | backend_init(struct wl_display *display, char *options) |
| 850 | { |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 851 | int width = 1024, height = 640, fullscreen = 0, count = 1, i; |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 852 | char *p, *value; |
| 853 | |
Kristian Høgsberg | 83eeacb | 2011-06-18 04:20:54 -0400 | [diff] [blame] | 854 | static char * const tokens[] = { |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 855 | "width", "height", "fullscreen", "output-count", NULL |
Kristian Høgsberg | 83eeacb | 2011-06-18 04:20:54 -0400 | [diff] [blame] | 856 | }; |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 857 | |
| 858 | p = options; |
| 859 | while (i = getsubopt(&p, tokens, &value), i != -1) { |
| 860 | switch (i) { |
| 861 | case 0: |
| 862 | width = strtol(value, NULL, 0); |
| 863 | break; |
| 864 | case 1: |
| 865 | height = strtol(value, NULL, 0); |
| 866 | break; |
Kristian Høgsberg | 83eeacb | 2011-06-18 04:20:54 -0400 | [diff] [blame] | 867 | case 2: |
| 868 | fullscreen = 1; |
| 869 | break; |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 870 | case 3: |
| 871 | count = strtol(value, NULL, 0); |
| 872 | break; |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 873 | } |
| 874 | } |
| 875 | |
Kristian Høgsberg | 1ccd9d2 | 2011-07-21 10:22:13 -0700 | [diff] [blame] | 876 | return x11_compositor_create(display, |
| 877 | width, height, count, fullscreen); |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 878 | } |