blob: 84eaf6c3b60303b89e252672d193b0569871cf43 [file] [log] [blame]
Benjamin Franzkeec2e6422010-11-27 19:04:12 +01001/*
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04002 * Copyright © 2010-2011 Benjamin Franzke
Benjamin Franzkeec2e6422010-11-27 19:04:12 +01003 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04004 * 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 Franzkeec2e6422010-11-27 19:04:12 +010013 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -040014 * 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 Franzkeec2e6422010-11-27 19:04:12 +010021 */
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 Stoneb7452fe2012-06-01 12:14:06 +010034#include <sys/mman.h>
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010035
Benjamin Franzkebe014562011-02-18 17:04:24 +010036#include <wayland-client.h>
37#include <wayland-egl.h>
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010038
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010039#include <GLES2/gl2.h>
40#include <GLES2/gl2ext.h>
41#include <EGL/egl.h>
42#include <EGL/eglext.h>
43
44#include "compositor.h"
45
46struct wayland_compositor {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050047 struct weston_compositor base;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010048
Kristian Høgsbergb5ef5912012-03-28 22:53:49 -040049 struct wl_egl_pixmap *dummy_pixmap;
Kristian Høgsbergb71302e2012-05-10 12:28:35 -040050 EGLSurface dummy_egl_surface;
Kristian Høgsbergb5ef5912012-03-28 22:53:49 -040051
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010052 struct {
Kristian Høgsberg362b6722012-06-18 15:13:51 -040053 struct wl_display *wl_display;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010054 struct wl_compositor *compositor;
55 struct wl_shell *shell;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010056 struct wl_output *output;
57
58 struct {
59 int32_t x, y, width, height;
60 } screen_allocation;
61
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010062 struct wl_event_source *wl_source;
63 uint32_t event_mask;
64 } parent;
65
Kristian Høgsberg546a8122012-02-01 07:45:51 -050066 struct {
67 int32_t top, bottom, left, right;
68 GLuint texture;
69 int32_t width, height;
70 } border;
71
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010072 struct wl_list input_list;
73};
74
75struct wayland_output {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050076 struct weston_output base;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010077
78 struct {
79 struct wl_surface *surface;
Pekka Paalanen9d1613e2011-11-25 12:09:16 +020080 struct wl_shell_surface *shell_surface;
Benjamin Franzkebe014562011-02-18 17:04:24 +010081 struct wl_egl_window *egl_window;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010082 } parent;
Benjamin Franzkebe014562011-02-18 17:04:24 +010083 EGLSurface egl_surface;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050084 struct weston_mode mode;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010085};
86
87struct wayland_input {
Kristian Høgsberg7af7ced2012-08-10 10:01:33 -040088 struct weston_seat base;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010089 struct wayland_compositor *compositor;
Daniel Stone37816df2012-05-16 18:45:18 +010090 struct wl_seat *seat;
91 struct wl_pointer *pointer;
92 struct wl_keyboard *keyboard;
93 struct wl_touch *touch;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010094 struct wl_list link;
Daniel Stone50692802012-06-22 13:21:41 +010095 uint32_t key_serial;
Kristian Høgsberg539d85f2012-08-13 23:29:53 -040096 uint32_t enter_serial;
97 int focus;
98 struct wayland_output *output;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010099};
100
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500101
102static int
103texture_border(struct wayland_output *output)
104{
105 struct wayland_compositor *c =
106 (struct wayland_compositor *) output->base.compositor;
107 GLfloat *d;
108 unsigned int *p;
109 int i, j, k, n;
110 GLfloat x[4], y[4], u[4], v[4];
111
112 x[0] = -c->border.left;
113 x[1] = 0;
114 x[2] = output->base.current->width;
115 x[3] = output->base.current->width + c->border.right;
116
117 y[0] = -c->border.top;
118 y[1] = 0;
119 y[2] = output->base.current->height;
120 y[3] = output->base.current->height + c->border.bottom;
121
122 u[0] = 0.0;
123 u[1] = (GLfloat) c->border.left / c->border.width;
124 u[2] = (GLfloat) (c->border.width - c->border.right) / c->border.width;
125 u[3] = 1.0;
126
127 v[0] = 0.0;
128 v[1] = (GLfloat) c->border.top / c->border.height;
129 v[2] = (GLfloat) (c->border.height - c->border.bottom) / c->border.height;
130 v[3] = 1.0;
131
132 n = 8;
133 d = wl_array_add(&c->base.vertices, n * 16 * sizeof *d);
134 p = wl_array_add(&c->base.indices, n * 6 * sizeof *p);
135
136 k = 0;
137 for (i = 0; i < 3; i++)
138 for (j = 0; j < 3; j++) {
139
140 if (i == 1 && j == 1)
141 continue;
142
143 d[ 0] = x[i];
144 d[ 1] = y[j];
145 d[ 2] = u[i];
146 d[ 3] = v[j];
147
148 d[ 4] = x[i];
149 d[ 5] = y[j + 1];
150 d[ 6] = u[i];
151 d[ 7] = v[j + 1];
152
153 d[ 8] = x[i + 1];
154 d[ 9] = y[j];
155 d[10] = u[i + 1];
156 d[11] = v[j];
157
158 d[12] = x[i + 1];
159 d[13] = y[j + 1];
160 d[14] = u[i + 1];
161 d[15] = v[j + 1];
162
163 p[0] = k + 0;
164 p[1] = k + 1;
165 p[2] = k + 2;
166 p[3] = k + 2;
167 p[4] = k + 1;
168 p[5] = k + 3;
169
170 d += 16;
171 p += 6;
172 k += 4;
173 }
174
175 return k / 4;
176}
177
178static void
179draw_border(struct wayland_output *output)
180{
181 struct wayland_compositor *c =
182 (struct wayland_compositor *) output->base.compositor;
Gwenole Beauchesne6d030492012-04-20 11:15:51 +0200183 struct weston_shader *shader = &c->base.texture_shader_rgba;
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500184 GLfloat *v;
185 int n;
186
187 glDisable(GL_BLEND);
188 glUseProgram(shader->program);
189 c->base.current_shader = shader;
190
191 glUniformMatrix4fv(shader->proj_uniform,
192 1, GL_FALSE, output->base.matrix.d);
193
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200194 glUniform1i(shader->tex_uniforms[0], 0);
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500195 glUniform1f(shader->alpha_uniform, 1);
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500196 glUniform1f(shader->texwidth_uniform, 1);
197
198 n = texture_border(output);
199
200 glBindTexture(GL_TEXTURE_2D, c->border.texture);
201
202 v = c->base.vertices.data;
203 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
204 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
205 glEnableVertexAttribArray(0);
206 glEnableVertexAttribArray(1);
207
208 glDrawElements(GL_TRIANGLES, n * 6,
209 GL_UNSIGNED_INT, c->base.indices.data);
210
211 glDisableVertexAttribArray(1);
212 glDisableVertexAttribArray(0);
213
214 c->base.vertices.size = 0;
215 c->base.indices.size = 0;
216}
217
218static void
219create_border(struct wayland_compositor *c)
220{
Ander Conselvan de Oliveirae2d21e82012-03-16 17:25:09 +0200221 pixman_image_t *image;
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500222
Ander Conselvan de Oliveirae2d21e82012-03-16 17:25:09 +0200223 image = load_image(DATADIR "/weston/border.png");
224 if (!image) {
Martin Minarik6d118362012-06-07 18:01:59 +0200225 weston_log("could'nt load border image\n");
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500226 return;
227 }
228
Ander Conselvan de Oliveirae2d21e82012-03-16 17:25:09 +0200229 c->border.width = pixman_image_get_width(image);
230 c->border.height = pixman_image_get_height(image);
231
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500232 glGenTextures(1, &c->border.texture);
233 glBindTexture(GL_TEXTURE_2D, c->border.texture);
234 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
235 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
236 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
237 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
238
239 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
240 c->border.width,
241 c->border.height,
Ander Conselvan de Oliveirae2d21e82012-03-16 17:25:09 +0200242 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE,
243 pixman_image_get_data(image));
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500244
245 c->border.top = 25;
246 c->border.bottom = 50;
247 c->border.left = 25;
248 c->border.right = 25;
Ander Conselvan de Oliveirae2d21e82012-03-16 17:25:09 +0200249
250 pixman_image_unref(image);
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500251}
252
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100253static int
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100254wayland_compositor_init_egl(struct wayland_compositor *c)
255{
256 EGLint major, minor;
Benjamin Franzkebe014562011-02-18 17:04:24 +0100257 EGLint n;
Benjamin Franzkebe014562011-02-18 17:04:24 +0100258 EGLint config_attribs[] = {
259 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
260 EGL_RED_SIZE, 1,
261 EGL_GREEN_SIZE, 1,
262 EGL_BLUE_SIZE, 1,
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500263 EGL_ALPHA_SIZE, 1,
Kristian Høgsbergd28ab362011-03-02 11:36:30 -0500264 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
Benjamin Franzkebe014562011-02-18 17:04:24 +0100265 EGL_NONE
266 };
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100267 static const EGLint context_attribs[] = {
268 EGL_CONTEXT_CLIENT_VERSION, 2,
269 EGL_NONE
270 };
271
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400272 c->base.egl_display = eglGetDisplay(c->parent.wl_display);
273 if (c->base.egl_display == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +0200274 weston_log("failed to create display\n");
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100275 return -1;
276 }
277
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400278 if (!eglInitialize(c->base.egl_display, &major, &minor)) {
Martin Minarik6d118362012-06-07 18:01:59 +0200279 weston_log("failed to initialize display\n");
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100280 return -1;
281 }
282
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100283 if (!eglBindAPI(EGL_OPENGL_ES_API)) {
Martin Minarik6d118362012-06-07 18:01:59 +0200284 weston_log("failed to bind EGL_OPENGL_ES_API\n");
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100285 return -1;
286 }
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400287 if (!eglChooseConfig(c->base.egl_display, config_attribs,
288 &c->base.egl_config, 1, &n) || n == 0) {
Martin Minarik6d118362012-06-07 18:01:59 +0200289 weston_log("failed to choose config: %d\n", n);
Benjamin Franzkebe014562011-02-18 17:04:24 +0100290 return -1;
291 }
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100292
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400293 c->base.egl_context =
294 eglCreateContext(c->base.egl_display, c->base.egl_config,
295 EGL_NO_CONTEXT, context_attribs);
296 if (c->base.egl_context == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +0200297 weston_log("failed to create context\n");
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100298 return -1;
299 }
300
Kristian Høgsbergb5ef5912012-03-28 22:53:49 -0400301 c->dummy_pixmap = wl_egl_pixmap_create(10, 10, 0);
302 if (!c->dummy_pixmap) {
Martin Minarik6d118362012-06-07 18:01:59 +0200303 weston_log("failure to create dummy_pixmap\n");
Kristian Høgsbergb5ef5912012-03-28 22:53:49 -0400304 return -1;
305 }
306
307 c->dummy_egl_surface =
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400308 eglCreatePixmapSurface(c->base.egl_display, c->base.egl_config,
Kristian Høgsbergb5ef5912012-03-28 22:53:49 -0400309 c->dummy_pixmap, NULL);
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400310 if (!eglMakeCurrent(c->base.egl_display, c->dummy_egl_surface,
311 c->dummy_egl_surface, c->base.egl_context)) {
Martin Minarik6d118362012-06-07 18:01:59 +0200312 weston_log("failed to make context current\n");
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100313 return -1;
314 }
315
316 return 0;
317}
318
Kristian Høgsberg68c479a2012-01-25 23:32:28 -0500319static void
Kristian Høgsbergcdd61d02012-02-07 09:56:15 -0500320frame_done(void *data, struct wl_callback *callback, uint32_t time)
Kristian Høgsberg33418202011-08-16 23:01:28 -0400321{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500322 struct weston_output *output = data;
Kristian Høgsberg33418202011-08-16 23:01:28 -0400323
Kristian Høgsbergcdd61d02012-02-07 09:56:15 -0500324 wl_callback_destroy(callback);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500325 weston_output_finish_frame(output, time);
Kristian Høgsberg33418202011-08-16 23:01:28 -0400326}
327
328static const struct wl_callback_listener frame_listener = {
329 frame_done
330};
331
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500332static void
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500333wayland_output_repaint(struct weston_output *output_base,
334 pixman_region32_t *damage)
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100335{
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100336 struct wayland_output *output = (struct wayland_output *) output_base;
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500337 struct wayland_compositor *compositor =
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100338 (struct wayland_compositor *) output->base.compositor;
Kristian Høgsberg33418202011-08-16 23:01:28 -0400339 struct wl_callback *callback;
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500340 struct weston_surface *surface;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100341
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400342 if (!eglMakeCurrent(compositor->base.egl_display, output->egl_surface,
343 output->egl_surface,
344 compositor->base.egl_context)) {
Martin Minarik6d118362012-06-07 18:01:59 +0200345 weston_log("failed to make current\n");
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500346 return;
347 }
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100348
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500349 wl_list_for_each_reverse(surface, &compositor->base.surface_list, link)
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500350 weston_surface_draw(surface, &output->base, damage);
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500351
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500352 draw_border(output);
353
Kristian Høgsberge0f832b2012-06-20 00:13:18 -0400354 wl_signal_emit(&output->base.frame_signal, output);
Scott Moreau062be7e2012-04-20 13:37:33 -0600355
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400356 eglSwapBuffers(compositor->base.egl_display, output->egl_surface);
Kristian Høgsberg33418202011-08-16 23:01:28 -0400357 callback = wl_surface_frame(output->parent.surface);
358 wl_callback_add_listener(callback, &frame_listener, output);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100359
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500360 return;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100361}
362
Matt Roper361d2ad2011-08-29 13:52:23 -0700363static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500364wayland_output_destroy(struct weston_output *output_base)
Matt Roper361d2ad2011-08-29 13:52:23 -0700365{
366 struct wayland_output *output = (struct wayland_output *) output_base;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500367 struct weston_compositor *ec = output->base.compositor;
Matt Roper361d2ad2011-08-29 13:52:23 -0700368
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400369 eglDestroySurface(ec->egl_display, output->egl_surface);
Matt Roper361d2ad2011-08-29 13:52:23 -0700370 wl_egl_window_destroy(output->parent.egl_window);
371 free(output);
372
373 return;
374}
375
Ander Conselvan de Oliveira563c5b82012-06-18 17:36:21 +0300376static const struct wl_shell_surface_listener shell_surface_listener;
377
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200378static int
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100379wayland_compositor_create_output(struct wayland_compositor *c,
380 int width, int height)
381{
382 struct wayland_output *output;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100383
384 output = malloc(sizeof *output);
385 if (output == NULL)
386 return -1;
387 memset(output, 0, sizeof *output);
388
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400389 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;
Scott Moreau1bad5db2012-08-18 01:04:05 -0600398 weston_output_init(&output->base, &c->base, 0, 0, width, height,
399 WL_OUTPUT_TRANSFORM_NORMAL);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400400
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500401 output->base.border.top = c->border.top;
402 output->base.border.bottom = c->border.bottom;
403 output->base.border.left = c->border.left;
404 output->base.border.right = c->border.right;
Kristian Høgsberg90bc88c2012-08-13 23:34:04 -0400405 output->base.make = "waywayland";
406 output->base.model = "none";
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500407
408 weston_output_move(&output->base, 0, 0);
409
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100410 output->parent.surface =
411 wl_compositor_create_surface(c->parent.compositor);
412 wl_surface_set_user_data(output->parent.surface, output);
413
Benjamin Franzkebe014562011-02-18 17:04:24 +0100414 output->parent.egl_window =
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500415 wl_egl_window_create(output->parent.surface,
416 width + c->border.left + c->border.right,
417 height + c->border.top + c->border.bottom);
Benjamin Franzkebe014562011-02-18 17:04:24 +0100418 if (!output->parent.egl_window) {
Martin Minarik6d118362012-06-07 18:01:59 +0200419 weston_log("failure to create wl_egl_window\n");
Benjamin Franzkebe014562011-02-18 17:04:24 +0100420 goto cleanup_output;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100421 }
422
Benjamin Franzkebe014562011-02-18 17:04:24 +0100423 output->egl_surface =
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400424 eglCreateWindowSurface(c->base.egl_display, c->base.egl_config,
Benjamin Franzkebe014562011-02-18 17:04:24 +0100425 output->parent.egl_window, NULL);
426 if (!output->egl_surface) {
Martin Minarik6d118362012-06-07 18:01:59 +0200427 weston_log("failed to create window surface\n");
Benjamin Franzkebe014562011-02-18 17:04:24 +0100428 goto cleanup_window;
429 }
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100430
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400431 if (!eglMakeCurrent(c->base.egl_display, output->egl_surface,
432 output->egl_surface, c->base.egl_context)) {
Martin Minarik6d118362012-06-07 18:01:59 +0200433 weston_log("failed to make surface current\n");
Benjamin Franzkebe014562011-02-18 17:04:24 +0100434 goto cleanup_surface;
435 return -1;
436 }
437
Pekka Paalanen9d1613e2011-11-25 12:09:16 +0200438 output->parent.shell_surface =
439 wl_shell_get_shell_surface(c->parent.shell,
440 output->parent.surface);
Ander Conselvan de Oliveira563c5b82012-06-18 17:36:21 +0300441 wl_shell_surface_add_listener(output->parent.shell_surface,
442 &shell_surface_listener, output);
Pekka Paalanen9d1613e2011-11-25 12:09:16 +0200443 wl_shell_surface_set_toplevel(output->parent.shell_surface);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100444
Alex Wubd3354b2012-04-17 17:20:49 +0800445 output->base.origin = output->base.current;
Kristian Høgsberg68c479a2012-01-25 23:32:28 -0500446 output->base.repaint = wayland_output_repaint;
Matt Roper361d2ad2011-08-29 13:52:23 -0700447 output->base.destroy = wayland_output_destroy;
Jesse Barnes5308a5e2012-02-09 13:12:57 -0800448 output->base.assign_planes = NULL;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +0200449 output->base.set_backlight = NULL;
450 output->base.set_dpms = NULL;
Alex Wu2dda6042012-04-17 17:20:47 +0800451 output->base.switch_mode = NULL;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100452
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100453 wl_list_insert(c->base.output_list.prev, &output->base.link);
454
455 return 0;
Benjamin Franzkebe014562011-02-18 17:04:24 +0100456
457cleanup_surface:
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400458 eglDestroySurface(c->base.egl_display, output->egl_surface);
Benjamin Franzkebe014562011-02-18 17:04:24 +0100459cleanup_window:
460 wl_egl_window_destroy(output->parent.egl_window);
461cleanup_output:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500462 /* FIXME: cleanup weston_output */
Benjamin Franzkebe014562011-02-18 17:04:24 +0100463 free(output);
464
465 return -1;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100466}
467
Ander Conselvan de Oliveira563c5b82012-06-18 17:36:21 +0300468static void
469shell_surface_ping(void *data, struct wl_shell_surface *shell_surface,
470 uint32_t serial)
471{
472 wl_shell_surface_pong(shell_surface, serial);
473}
474
475static void
476shell_surface_configure(void *data, struct wl_shell_surface *shell_surface,
477 uint32_t edges, int32_t width, int32_t height)
478{
479 /* FIXME: implement resizing */
480}
481
482static void
483shell_surface_popup_done(void *data, struct wl_shell_surface *shell_surface)
484{
485}
486
487static const struct wl_shell_surface_listener shell_surface_listener = {
488 shell_surface_ping,
489 shell_surface_configure,
490 shell_surface_popup_done
491};
492
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100493/* Events received from the wayland-server this compositor is client of: */
494
495/* parent output interface */
496static void
497display_handle_geometry(void *data,
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400498 struct wl_output *wl_output,
499 int x,
500 int y,
501 int physical_width,
502 int physical_height,
503 int subpixel,
504 const char *make,
Kristian Høgsberg0e696472012-07-22 15:49:57 -0400505 const char *model,
506 int transform)
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100507{
508 struct wayland_compositor *c = data;
509
Kristian Høgsbergf8fc08f2010-12-01 20:10:10 -0500510 c->parent.screen_allocation.x = x;
511 c->parent.screen_allocation.y = y;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400512}
513
514static void
515display_handle_mode(void *data,
516 struct wl_output *wl_output,
517 uint32_t flags,
518 int width,
519 int height,
520 int refresh)
521{
522 struct wayland_compositor *c = data;
523
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100524 c->parent.screen_allocation.width = width;
525 c->parent.screen_allocation.height = height;
526}
527
528static const struct wl_output_listener output_listener = {
529 display_handle_geometry,
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400530 display_handle_mode
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100531};
532
Kristian Høgsberg539d85f2012-08-13 23:29:53 -0400533static void
534check_focus(struct wayland_input *input, wl_fixed_t x, wl_fixed_t y)
535{
536 struct wayland_compositor *c = input->compositor;
537 int width, height, inside;
538
539 width = input->output->mode.width;
540 height = input->output->mode.height;
541
542 inside = c->border.left <= wl_fixed_to_int(x) &&
543 wl_fixed_to_int(x) < width + c->border.left &&
544 c->border.top <= wl_fixed_to_int(y) &&
545 wl_fixed_to_int(y) < height + c->border.top;
546
547 if (!input->focus && inside) {
548 notify_pointer_focus(&input->base, &input->output->base,
549 x - wl_fixed_from_int(c->border.left),
550 y = wl_fixed_from_int(c->border.top));
551 wl_pointer_set_cursor(input->pointer,
552 input->enter_serial, NULL, 0, 0);
553 } else if (input->focus && !inside) {
554 notify_pointer_focus(&input->base, NULL, 0, 0);
555 /* FIXME: Should set default cursor here. */
556 }
557
558 input->focus = inside;
559}
560
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100561/* parent input interface */
562static void
Daniel Stone37816df2012-05-16 18:45:18 +0100563input_handle_pointer_enter(void *data, struct wl_pointer *pointer,
564 uint32_t serial, struct wl_surface *surface,
Kristian Høgsberge11bbe42012-05-09 12:19:04 -0400565 wl_fixed_t x, wl_fixed_t y)
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100566{
567 struct wayland_input *input = data;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100568
Daniel Stone50692802012-06-22 13:21:41 +0100569 /* XXX: If we get a modifier event immediately before the focus,
570 * we should try to keep the same serial. */
Kristian Høgsberg539d85f2012-08-13 23:29:53 -0400571 input->enter_serial = serial;
572 input->output = wl_surface_get_user_data(surface);
573 check_focus(input, x, y);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100574}
575
576static void
Daniel Stone37816df2012-05-16 18:45:18 +0100577input_handle_pointer_leave(void *data, struct wl_pointer *pointer,
578 uint32_t serial, struct wl_surface *surface)
Kristian Høgsberg06d58b72012-02-23 09:59:05 -0500579{
580 struct wayland_input *input = data;
Kristian Høgsberg06d58b72012-02-23 09:59:05 -0500581
Kristian Høgsbergcb3eaae2012-08-10 09:50:11 -0400582 notify_pointer_focus(&input->base, NULL, 0, 0);
Kristian Høgsberg539d85f2012-08-13 23:29:53 -0400583 input->output = NULL;
584 input->focus = 0;
Kristian Høgsberg06d58b72012-02-23 09:59:05 -0500585}
586
587static void
Daniel Stone37816df2012-05-16 18:45:18 +0100588input_handle_motion(void *data, struct wl_pointer *pointer,
589 uint32_t time, wl_fixed_t x, wl_fixed_t y)
590{
591 struct wayland_input *input = data;
592 struct wayland_compositor *c = input->compositor;
593
Kristian Høgsberg539d85f2012-08-13 23:29:53 -0400594 check_focus(input, x, y);
595 if (input->focus)
596 notify_motion(&input->base, time,
597 x - wl_fixed_from_int(c->border.left),
598 y - wl_fixed_from_int(c->border.top));
Daniel Stone37816df2012-05-16 18:45:18 +0100599}
600
601static void
602input_handle_button(void *data, struct wl_pointer *pointer,
Daniel Stone4dbadb12012-05-30 16:31:51 +0100603 uint32_t serial, uint32_t time, uint32_t button,
604 uint32_t state_w)
Daniel Stone37816df2012-05-16 18:45:18 +0100605{
606 struct wayland_input *input = data;
Daniel Stone4dbadb12012-05-30 16:31:51 +0100607 enum wl_pointer_button_state state = state_w;
Daniel Stone37816df2012-05-16 18:45:18 +0100608
Kristian Høgsbergcb3eaae2012-08-10 09:50:11 -0400609 notify_button(&input->base, time, button, state);
Daniel Stone37816df2012-05-16 18:45:18 +0100610}
611
612static void
613input_handle_axis(void *data, struct wl_pointer *pointer,
Daniel Stone2fce4022012-05-30 16:32:00 +0100614 uint32_t time, uint32_t axis, wl_fixed_t value)
Daniel Stone37816df2012-05-16 18:45:18 +0100615{
616 struct wayland_input *input = data;
Daniel Stone37816df2012-05-16 18:45:18 +0100617
Kristian Høgsbergcb3eaae2012-08-10 09:50:11 -0400618 notify_axis(&input->base, time, axis, value);
Daniel Stone37816df2012-05-16 18:45:18 +0100619}
620
621static const struct wl_pointer_listener pointer_listener = {
622 input_handle_pointer_enter,
623 input_handle_pointer_leave,
624 input_handle_motion,
625 input_handle_button,
626 input_handle_axis,
627};
628
629static void
Daniel Stoneb7452fe2012-06-01 12:14:06 +0100630input_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format,
631 int fd, uint32_t size)
632{
633 struct wayland_input *input = data;
634 struct xkb_keymap *keymap;
635 char *map_str;
636
637 if (!data) {
638 close(fd);
639 return;
640 }
641
642 if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
643 close(fd);
644 return;
645 }
646
647 map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
648 if (map_str == MAP_FAILED) {
649 close(fd);
650 return;
651 }
652
653 keymap = xkb_map_new_from_string(input->compositor->base.xkb_context,
654 map_str,
655 XKB_KEYMAP_FORMAT_TEXT_V1,
656 0);
657 munmap(map_str, size);
658 close(fd);
659
660 if (!keymap) {
Martin Minarik6d118362012-06-07 18:01:59 +0200661 weston_log("failed to compile keymap\n");
Daniel Stoneb7452fe2012-06-01 12:14:06 +0100662 return;
663 }
664
Kristian Høgsberg7af7ced2012-08-10 10:01:33 -0400665 weston_seat_init_keyboard(&input->base, keymap);
Daniel Stoneb7452fe2012-06-01 12:14:06 +0100666 xkb_map_unref(keymap);
667}
668
669static void
Kristian Høgsberg06d58b72012-02-23 09:59:05 -0500670input_handle_keyboard_enter(void *data,
Daniel Stone37816df2012-05-16 18:45:18 +0100671 struct wl_keyboard *keyboard,
672 uint32_t serial,
Kristian Høgsberg06d58b72012-02-23 09:59:05 -0500673 struct wl_surface *surface,
674 struct wl_array *keys)
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100675{
Kristian Høgsbergaf82bea2011-01-27 20:18:17 -0500676 struct wayland_input *input = data;
Kristian Høgsbergaf82bea2011-01-27 20:18:17 -0500677
Daniel Stone50692802012-06-22 13:21:41 +0100678 /* XXX: If we get a modifier event immediately before the focus,
679 * we should try to keep the same serial. */
Kristian Høgsbergcb3eaae2012-08-10 09:50:11 -0400680 notify_keyboard_focus_in(&input->base, keys,
Daniel Stoned6da09e2012-06-22 13:21:29 +0100681 STATE_UPDATE_AUTOMATIC);
Kristian Høgsberg06d58b72012-02-23 09:59:05 -0500682}
683
684static void
685input_handle_keyboard_leave(void *data,
Daniel Stone37816df2012-05-16 18:45:18 +0100686 struct wl_keyboard *keyboard,
687 uint32_t serial,
Kristian Høgsberg06d58b72012-02-23 09:59:05 -0500688 struct wl_surface *surface)
689{
690 struct wayland_input *input = data;
Kristian Høgsberg06d58b72012-02-23 09:59:05 -0500691
Kristian Høgsbergcb3eaae2012-08-10 09:50:11 -0400692 notify_keyboard_focus_out(&input->base);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100693}
694
Daniel Stone37816df2012-05-16 18:45:18 +0100695static void
696input_handle_key(void *data, struct wl_keyboard *keyboard,
697 uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
698{
699 struct wayland_input *input = data;
Daniel Stone37816df2012-05-16 18:45:18 +0100700
Daniel Stone50692802012-06-22 13:21:41 +0100701 input->key_serial = serial;
Kristian Høgsbergcb3eaae2012-08-10 09:50:11 -0400702 notify_key(&input->base, time, key,
Daniel Stonec9785ea2012-05-30 16:31:52 +0100703 state ? WL_KEYBOARD_KEY_STATE_PRESSED :
Daniel Stone1b4e11f2012-06-22 13:21:37 +0100704 WL_KEYBOARD_KEY_STATE_RELEASED,
Daniel Stone50692802012-06-22 13:21:41 +0100705 STATE_UPDATE_NONE);
Daniel Stone37816df2012-05-16 18:45:18 +0100706}
707
Daniel Stone351eb612012-05-31 15:27:47 -0400708static void
709input_handle_modifiers(void *data, struct wl_keyboard *keyboard,
Daniel Stone50692802012-06-22 13:21:41 +0100710 uint32_t serial_in, uint32_t mods_depressed,
Daniel Stone351eb612012-05-31 15:27:47 -0400711 uint32_t mods_latched, uint32_t mods_locked,
712 uint32_t group)
713{
Daniel Stone50692802012-06-22 13:21:41 +0100714 struct wayland_input *input = data;
715 struct wayland_compositor *c = input->compositor;
716 uint32_t serial_out;
717
718 /* If we get a key event followed by a modifier event with the
719 * same serial number, then we try to preserve those semantics by
720 * reusing the same serial number on the way out too. */
721 if (serial_in == input->key_serial)
722 serial_out = wl_display_get_serial(c->base.wl_display);
723 else
724 serial_out = wl_display_next_serial(c->base.wl_display);
725
Kristian Høgsberg7af7ced2012-08-10 10:01:33 -0400726 xkb_state_update_mask(input->base.xkb_state.state,
Daniel Stone50692802012-06-22 13:21:41 +0100727 mods_depressed, mods_latched,
728 mods_locked, 0, 0, group);
Kristian Høgsbergcb3eaae2012-08-10 09:50:11 -0400729 notify_modifiers(&input->base, serial_out);
Daniel Stone351eb612012-05-31 15:27:47 -0400730}
731
Daniel Stone37816df2012-05-16 18:45:18 +0100732static const struct wl_keyboard_listener keyboard_listener = {
Daniel Stoneb7452fe2012-06-01 12:14:06 +0100733 input_handle_keymap,
Kristian Høgsberg06d58b72012-02-23 09:59:05 -0500734 input_handle_keyboard_enter,
735 input_handle_keyboard_leave,
Daniel Stone37816df2012-05-16 18:45:18 +0100736 input_handle_key,
Daniel Stone351eb612012-05-31 15:27:47 -0400737 input_handle_modifiers,
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100738};
739
740static void
Daniel Stone37816df2012-05-16 18:45:18 +0100741input_handle_capabilities(void *data, struct wl_seat *seat,
742 enum wl_seat_capability caps)
743{
744 struct wayland_input *input = data;
745
746 if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->pointer) {
747 input->pointer = wl_seat_get_pointer(seat);
748 wl_pointer_set_user_data(input->pointer, input);
749 wl_pointer_add_listener(input->pointer, &pointer_listener,
750 input);
Kristian Høgsberg7af7ced2012-08-10 10:01:33 -0400751 weston_seat_init_pointer(&input->base);
Daniel Stone37816df2012-05-16 18:45:18 +0100752 } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && input->pointer) {
753 wl_pointer_destroy(input->pointer);
754 input->pointer = NULL;
755 }
756
757 if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !input->keyboard) {
758 input->keyboard = wl_seat_get_keyboard(seat);
759 wl_keyboard_set_user_data(input->keyboard, input);
760 wl_keyboard_add_listener(input->keyboard, &keyboard_listener,
761 input);
762 } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && input->keyboard) {
763 wl_keyboard_destroy(input->keyboard);
764 input->keyboard = NULL;
765 }
766}
767
768static const struct wl_seat_listener seat_listener = {
769 input_handle_capabilities,
770};
771
772static void
773display_add_seat(struct wayland_compositor *c, uint32_t id)
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100774{
775 struct wayland_input *input;
776
777 input = malloc(sizeof *input);
778 if (input == NULL)
779 return;
780
781 memset(input, 0, sizeof *input);
782
Kristian Høgsberg7af7ced2012-08-10 10:01:33 -0400783 weston_seat_init(&input->base, &c->base);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100784 input->compositor = c;
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400785 input->seat = wl_display_bind(c->parent.wl_display, id,
Daniel Stone37816df2012-05-16 18:45:18 +0100786 &wl_seat_interface);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100787 wl_list_insert(c->input_list.prev, &input->link);
788
Daniel Stone37816df2012-05-16 18:45:18 +0100789 wl_seat_add_listener(input->seat, &seat_listener, input);
790 wl_seat_set_user_data(input->seat, input);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100791}
792
793static void
794display_handle_global(struct wl_display *display, uint32_t id,
795 const char *interface, uint32_t version, void *data)
796{
797 struct wayland_compositor *c = data;
798
Benjamin Franzke080ab6c2011-04-30 10:41:27 +0200799 if (strcmp(interface, "wl_compositor") == 0) {
Kristian Høgsbergf790c792011-08-19 14:41:57 -0400800 c->parent.compositor =
801 wl_display_bind(display, id, &wl_compositor_interface);
Benjamin Franzke080ab6c2011-04-30 10:41:27 +0200802 } else if (strcmp(interface, "wl_output") == 0) {
Kristian Høgsbergf790c792011-08-19 14:41:57 -0400803 c->parent.output =
804 wl_display_bind(display, id, &wl_output_interface);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100805 wl_output_add_listener(c->parent.output, &output_listener, c);
Benjamin Franzke080ab6c2011-04-30 10:41:27 +0200806 } else if (strcmp(interface, "wl_shell") == 0) {
Kristian Høgsbergf790c792011-08-19 14:41:57 -0400807 c->parent.shell =
808 wl_display_bind(display, id, &wl_shell_interface);
Daniel Stone725c2c32012-06-22 14:04:36 +0100809 } else if (strcmp(interface, "wl_seat") == 0) {
810 display_add_seat(c, id);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100811 }
812}
813
814static int
815update_event_mask(uint32_t mask, void *data)
816{
817 struct wayland_compositor *c = data;
818
819 c->parent.event_mask = mask;
820 if (c->parent.wl_source)
821 wl_event_source_fd_update(c->parent.wl_source, mask);
822
823 return 0;
824}
825
Kristian Høgsberg95d843d2011-04-22 13:01:26 -0400826static int
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100827wayland_compositor_handle_event(int fd, uint32_t mask, void *data)
828{
829 struct wayland_compositor *c = data;
830
831 if (mask & WL_EVENT_READABLE)
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400832 wl_display_iterate(c->parent.wl_display, WL_DISPLAY_READABLE);
Kristian Høgsbergf258a312011-12-28 22:51:20 -0500833 if (mask & WL_EVENT_WRITABLE)
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400834 wl_display_iterate(c->parent.wl_display, WL_DISPLAY_WRITABLE);
Kristian Høgsberg95d843d2011-04-22 13:01:26 -0400835
836 return 1;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100837}
838
Kristian Høgsbergcaa64422010-12-01 16:52:15 -0500839static void
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -0400840wayland_restore(struct weston_compositor *ec)
841{
842}
843
844static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500845wayland_destroy(struct weston_compositor *ec)
Kristian Høgsbergcaa64422010-12-01 16:52:15 -0500846{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500847 weston_compositor_shutdown(ec);
Matt Roper361d2ad2011-08-29 13:52:23 -0700848
Kristian Høgsbergcaa64422010-12-01 16:52:15 -0500849 free(ec);
850}
851
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500852static struct weston_compositor *
Kristian Høgsberg2e28b102012-02-07 09:57:25 -0500853wayland_compositor_create(struct wl_display *display,
Daniel Stonebaf43592012-06-01 11:11:10 -0400854 int width, int height, const char *display_name,
Daniel Stonec1be8e52012-06-01 11:14:02 -0400855 int argc, char *argv[], const char *config_file)
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100856{
857 struct wayland_compositor *c;
858 struct wl_event_loop *loop;
859 int fd;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100860
861 c = malloc(sizeof *c);
862 if (c == NULL)
863 return NULL;
864
865 memset(c, 0, sizeof *c);
866
Daniel Stone725c2c32012-06-22 14:04:36 +0100867 if (weston_compositor_init(&c->base, display, argc, argv,
868 config_file) < 0)
Martin Olssonc5db50f2012-07-08 03:03:43 +0200869 goto err_free;
Daniel Stone725c2c32012-06-22 14:04:36 +0100870
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400871 c->parent.wl_display = wl_display_connect(display_name);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100872
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400873 if (c->parent.wl_display == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +0200874 weston_log("failed to create display: %m\n");
Martin Olssonc5db50f2012-07-08 03:03:43 +0200875 goto err_compositor;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100876 }
877
878 wl_list_init(&c->input_list);
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400879 wl_display_add_global_listener(c->parent.wl_display,
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100880 display_handle_global, c);
881
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400882 wl_display_iterate(c->parent.wl_display, WL_DISPLAY_READABLE);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100883
884 c->base.wl_display = display;
885 if (wayland_compositor_init_egl(c) < 0)
Martin Olssonc5db50f2012-07-08 03:03:43 +0200886 goto err_display;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100887
Benjamin Franzkeecfb2b92011-01-15 12:34:48 +0100888 c->base.destroy = wayland_destroy;
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -0400889 c->base.restore = wayland_restore;
Benjamin Franzkeecfb2b92011-01-15 12:34:48 +0100890
Daniel Stone725c2c32012-06-22 14:04:36 +0100891 if (weston_compositor_init_gl(&c->base) < 0)
Martin Olssonc5db50f2012-07-08 03:03:43 +0200892 goto err_display;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100893
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500894 create_border(c);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100895 if (wayland_compositor_create_output(c, width, height) < 0)
Martin Olssonc5db50f2012-07-08 03:03:43 +0200896 goto err_display;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100897
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100898 loop = wl_display_get_event_loop(c->base.wl_display);
899
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400900 fd = wl_display_get_fd(c->parent.wl_display, update_event_mask, c);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100901 c->parent.wl_source =
902 wl_event_loop_add_fd(loop, fd, c->parent.event_mask,
903 wayland_compositor_handle_event, c);
904 if (c->parent.wl_source == NULL)
Martin Olssonc5db50f2012-07-08 03:03:43 +0200905 goto err_display;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100906
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100907 return &c->base;
Martin Olssonc5db50f2012-07-08 03:03:43 +0200908
909err_display:
910 wl_display_disconnect(c->parent.wl_display);
911err_compositor:
912 weston_compositor_shutdown(&c->base);
913err_free:
914 free(c);
915 return NULL;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100916}
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400917
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500918WL_EXPORT struct weston_compositor *
Daniel Stonec1be8e52012-06-01 11:14:02 -0400919backend_init(struct wl_display *display, int argc, char *argv[],
920 const char *config_file)
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400921{
Kristian Høgsbergbcacef12012-03-11 21:05:57 -0400922 int width = 1024, height = 640;
923 char *display_name = NULL;
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400924
Kristian Høgsbergbcacef12012-03-11 21:05:57 -0400925 const struct weston_option wayland_options[] = {
926 { WESTON_OPTION_INTEGER, "width", 0, &width },
927 { WESTON_OPTION_INTEGER, "height", 0, &height },
928 { WESTON_OPTION_STRING, "display", 0, &display_name },
929 };
930
931 parse_options(wayland_options,
932 ARRAY_LENGTH(wayland_options), argc, argv);
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400933
Daniel Stonebaf43592012-06-01 11:11:10 -0400934 return wayland_compositor_create(display, width, height, display_name,
Daniel Stonec1be8e52012-06-01 11:14:02 -0400935 argc, argv, config_file);
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400936}