blob: 11cdb59347c2c92a8de1460cf4d7595c5e5dedac [file] [log] [blame]
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001/*
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04002 * Copyright © 2008-2011 Kristian Høgsberg
3 * Copyright © 2010-2011 Intel Corporation
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04004 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04005 * 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øgsbergce5325d2010-06-14 11:54:00 -040014 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -040015 * 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øgsbergce5325d2010-06-14 11:54:00 -040022 */
23
Chia-I Wu1b6c0ed2010-10-29 15:20:18 +080024#ifdef HAVE_CONFIG_H
25#include <config.h>
26#endif
27
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040028#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øgsbergf9112b22010-06-14 12:53:43 -040036#include <linux/input.h>
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040037
38#include <xcb/xcb.h>
Benjamin Franzke3b288af2011-02-20 19:58:42 +010039#include <X11/Xlib.h>
40#include <X11/Xlib-xcb.h>
41
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040042#include <GLES2/gl2.h>
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040043#include <EGL/egl.h>
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040044
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040045#include "compositor.h"
46
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040047struct x11_compositor {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050048 struct weston_compositor base;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040049
Benjamin Franzke3b288af2011-02-20 19:58:42 +010050 Display *dpy;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040051 xcb_connection_t *conn;
52 xcb_screen_t *screen;
53 xcb_cursor_t null_cursor;
Kristian Høgsberg3ba48582011-01-27 11:57:19 -050054 struct wl_array keys;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040055 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øgsberg24ed6212011-01-26 14:02:31 -050061 xcb_atom_t wm_class;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040062 xcb_atom_t net_wm_name;
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -050063 xcb_atom_t net_wm_icon;
Kristian Høgsberg83eeacb2011-06-18 04:20:54 -040064 xcb_atom_t net_wm_state;
65 xcb_atom_t net_wm_state_fullscreen;
Kristian Høgsberg24ed6212011-01-26 14:02:31 -050066 xcb_atom_t string;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040067 xcb_atom_t utf8_string;
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -050068 xcb_atom_t cardinal;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040069 } atom;
70};
71
72struct x11_output {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050073 struct weston_output base;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040074
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040075 xcb_window_t window;
Benjamin Franzke84290d02011-03-02 10:07:59 +010076 EGLSurface egl_surface;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050077 struct weston_mode mode;
Kristian Høgsberg06a670f2011-10-29 14:39:13 -040078 struct wl_event_source *finish_frame_timer;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040079};
80
81struct x11_input {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050082 struct weston_input_device base;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040083};
84
85
Darxus55973f22010-11-22 21:24:39 -050086static int
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040087x11_input_create(struct x11_compositor *c)
88{
89 struct x11_input *input;
90
91 input = malloc(sizeof *input);
92 if (input == NULL)
Darxus55973f22010-11-22 21:24:39 -050093 return -1;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040094
95 memset(input, 0, sizeof *input);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050096 weston_input_device_init(&input->base, &c->base);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040097
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -050098 c->base.input_device = &input->base.input_device;
Darxus55973f22010-11-22 21:24:39 -050099
100 return 0;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400101}
102
Pekka Paalanen43c61d82012-01-03 11:58:34 +0200103static void
104x11_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øgsberg3466bc82012-01-03 11:29:15 -0500110 weston_input_device_release(&input->base);
Pekka Paalanen43c61d82012-01-03 11:58:34 +0200111 free(input);
112}
113
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400114static int
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400115x11_compositor_init_egl(struct x11_compositor *c)
116{
Kristian Høgsberg379b6782010-07-28 22:52:28 -0400117 EGLint major, minor;
Benjamin Franzke84290d02011-03-02 10:07:59 +0100118 EGLint n;
Kristian Høgsberg379b6782010-07-28 22:52:28 -0400119 const char *extensions;
Benjamin Franzke84290d02011-03-02 10:07:59 +0100120 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øgsberg2c28aa52010-07-28 23:47:54 -0400129 static const EGLint context_attribs[] = {
130 EGL_CONTEXT_CLIENT_VERSION, 2,
131 EGL_NONE
132 };
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400133
Benjamin Franzke3b288af2011-02-20 19:58:42 +0100134 c->base.display = eglGetDisplay(c->dpy);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400135 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øgsberg379b6782010-07-28 22:52:28 -0400145 extensions = eglQueryString(c->base.display, EGL_EXTENSIONS);
Ander Conselvan de Oliveiraef7c8d92011-11-01 16:37:41 +0200146 if (!strstr(extensions, "EGL_KHR_surfaceless_gles2")) {
147 fprintf(stderr, "EGL_KHR_surfaceless_gles2 not available\n");
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400148 return -1;
149 }
150
Darxus55973f22010-11-22 21:24:39 -0500151 if (!eglBindAPI(EGL_OPENGL_ES_API)) {
152 fprintf(stderr, "failed to bind EGL_OPENGL_ES_API\n");
153 return -1;
154 }
Benjamin Franzke84290d02011-03-02 10:07:59 +0100155 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 }
Darxus55973f22010-11-22 21:24:39 -0500160
Benjamin Franzke84290d02011-03-02 10:07:59 +0100161 c->base.context = eglCreateContext(c->base.display, c->base.config,
Kristian Høgsberg2c28aa52010-07-28 23:47:54 -0400162 EGL_NO_CONTEXT, context_attribs);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400163 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 Paalanen43c61d82012-01-03 11:58:34 +0200177static void
178x11_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 Franzkeeefc36c2011-03-11 16:39:20 +0100188static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500189x11_output_prepare_render(struct weston_output *output_base)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100190{
191 struct x11_output *output = (struct x11_output *) output_base;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500192 struct weston_compositor *ec = output->base.compositor;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100193
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 Franzkeec4d3422011-03-14 12:07:26 +0100203static int
Kristian Høgsberg06a670f2011-10-29 14:39:13 -0400204finish_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øgsberg8334bc12012-01-03 10:29:47 -0500212 weston_output_finish_frame(&output->base, msec);
Kristian Høgsberg06a670f2011-10-29 14:39:13 -0400213
214 return 1;
215}
216
217static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500218x11_output_present(struct weston_output *output_base)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400219{
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100220 struct x11_output *output = (struct x11_output *) output_base;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500221 struct weston_compositor *ec = output->base.compositor;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400222
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100223 if (x11_output_prepare_render(&output->base))
224 return -1;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100225
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100226 eglSwapBuffers(ec->display, output->egl_surface);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400227
Kristian Høgsberg06a670f2011-10-29 14:39:13 -0400228 wl_event_source_timer_update(output->finish_frame_timer, 10);
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100229
230 return 0;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400231}
232
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200233static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500234x11_output_prepare_scanout_surface(struct weston_output *output_base,
235 struct weston_surface *es)
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200236{
Benjamin Franzke66aa2352011-04-20 17:06:13 +0200237 return -1;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200238}
239
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200240static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500241x11_output_set_cursor(struct weston_output *output_base,
242 struct weston_input_device *input)
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200243{
244 return -1;
245}
246
Matt Roper361d2ad2011-08-29 13:52:23 -0700247static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500248x11_output_destroy(struct weston_output *output_base)
Matt Roper361d2ad2011-08-29 13:52:23 -0700249{
Pekka Paalanen2de99e22012-01-03 11:51:03 +0200250 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øgsberg3466bc82012-01-03 11:29:15 -0500261 weston_output_destroy(&output->base);
Pekka Paalanen2de99e22012-01-03 11:51:03 +0200262
263 free(output);
Matt Roper361d2ad2011-08-29 13:52:23 -0700264}
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200265
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400266static void
267x11_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øgsberg09e26922011-12-23 13:33:45 -0500280 ARRAY_LENGTH(list),
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400281 list);
282}
283
Kristian Høgsberg83eeacb2011-06-18 04:20:54 -0400284static void
285x11_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øgsbergce5325d2010-06-14 11:54:00 -0400316struct 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øgsbergf58d8ca2011-01-26 14:37:07 -0500331static void
Kristian Høgsbergb41d76c2011-04-23 15:03:15 -0400332x11_output_set_icon(struct x11_compositor *c,
333 struct x11_output *output, const char *filename)
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500334{
Kristian Høgsbergb41d76c2011-04-23 15:03:15 -0400335 uint32_t *icon, *pixels, stride;
336 int32_t width, height;
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500337
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500338 pixels = weston_load_image(filename, &width, &height, &stride);
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500339 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øgsbergce5325d2010-06-14 11:54:00 -0400357static int
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700358x11_compositor_create_output(struct x11_compositor *c, int x, int y,
Kristian Høgsberg83eeacb2011-06-18 04:20:54 -0400359 int width, int height, int fullscreen)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400360{
361 static const char name[] = "Wayland Compositor";
Kristian Høgsberg24ed6212011-01-26 14:02:31 -0500362 static const char class[] = "wayland-1\0Wayland Compositor";
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400363 struct x11_output *output;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400364 xcb_screen_iterator_t iter;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400365 struct wm_normal_hints normal_hints;
Kristian Høgsberg06a670f2011-10-29 14:39:13 -0400366 struct wl_event_loop *loop;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400367 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øgsberg86e09892010-07-07 09:51:11 -0400375 XCB_EVENT_MASK_STRUCTURE_NOTIFY |
376 XCB_EVENT_MASK_ENTER_WINDOW |
Kristian Høgsberg3ba48582011-01-27 11:57:19 -0500377 XCB_EVENT_MASK_LEAVE_WINDOW |
378 XCB_EVENT_MASK_KEYMAP_STATE |
379 XCB_EVENT_MASK_FOCUS_CHANGE,
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400380 0
381 };
382
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400383 output = malloc(sizeof *output);
384 if (output == NULL)
385 return -1;
386
387 memset(output, 0, sizeof *output);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400388
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øgsberg8334bc12012-01-03 10:29:47 -0500398 weston_output_init(&output->base, &c->base, x, y, width, height,
Benjamin Franzke84290d02011-03-02 10:07:59 +0100399 WL_OUTPUT_FLIPPED);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400400
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øgsbergce5325d2010-06-14 11:54:00 -0400429 /* 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øgsberg24ed6212011-01-26 14:02:31 -0500433 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øgsbergb41d76c2011-04-23 15:03:15 -0400437 x11_output_set_icon(c, output, DATADIR "/wayland/wayland.png");
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500438
Kristian Høgsberg24ed6212011-01-26 14:02:31 -0500439 xcb_map_window(c->conn, output->window);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400440
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400441 x11_output_set_wm_protocols(output);
442
Kristian Høgsberg83eeacb2011-06-18 04:20:54 -0400443 if (fullscreen)
444 x11_output_change_state(output, 1,
445 c->atom.net_wm_state_fullscreen);
446
Benjamin Franzke84290d02011-03-02 10:07:59 +0100447 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øgsbergce5325d2010-06-14 11:54:00 -0400452 return -1;
453 }
Benjamin Franzke84290d02011-03-02 10:07:59 +0100454 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øgsbergce5325d2010-06-14 11:54:00 -0400459
Kristian Høgsberg06a670f2011-10-29 14:39:13 -0400460 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 Franzkeeefc36c2011-03-11 16:39:20 +0100464 output->base.prepare_render = x11_output_prepare_render;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100465 output->base.present = x11_output_present;
Benjamin Franzke66aa2352011-04-20 17:06:13 +0200466 output->base.prepare_scanout_surface =
467 x11_output_prepare_scanout_surface;
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200468 output->base.set_hardware_cursor = x11_output_set_cursor;
Matt Roper361d2ad2011-08-29 13:52:23 -0700469 output->base.destroy = x11_output_destroy;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100470
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400471 wl_list_insert(c->base.output_list.prev, &output->base.link);
472
473 return 0;
474}
475
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400476static struct x11_output *
477x11_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 Vignattia3a71622011-12-08 17:03:17 +0200489static void
490x11_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øgsberg8334bc12012-01-03 10:29:47 -0500520 weston_compositor_get_time(), button, state);
Tiago Vignattia3a71622011-12-08 17:03:17 +0200521}
522
Kristian Høgsbergee724822011-04-21 14:51:44 -0400523static int
524x11_compositor_next_event(struct x11_compositor *c,
Kristian Høgsberg127d0f02011-04-22 12:18:13 -0400525 xcb_generic_event_t **event, uint32_t mask)
Kristian Høgsbergee724822011-04-21 14:51:44 -0400526{
Kristian Høgsberg127d0f02011-04-22 12:18:13 -0400527 if (mask & WL_EVENT_READABLE) {
528 *event = xcb_poll_for_event(c->conn);
Kristian Høgsbergee724822011-04-21 14:51:44 -0400529 } else {
Kristian Høgsberg82ed0422011-04-25 15:41:59 -0400530#ifdef HAVE_XCB_POLL_FOR_QUEUED_EVENT
Kristian Høgsberg127d0f02011-04-22 12:18:13 -0400531 *event = xcb_poll_for_queued_event(c->conn);
Kristian Høgsberg82ed0422011-04-25 15:41:59 -0400532#else
533 *event = xcb_poll_for_event(c->conn);
534#endif
Kristian Høgsbergee724822011-04-21 14:51:44 -0400535 }
536
537 return *event != NULL;
538}
539
Kristian Høgsberg127d0f02011-04-22 12:18:13 -0400540static int
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400541x11_compositor_handle_event(int fd, uint32_t mask, void *data)
542{
543 struct x11_compositor *c = data;
544 struct x11_output *output;
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400545 xcb_generic_event_t *event, *prev;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400546 xcb_client_message_event_t *client_message;
547 xcb_motion_notify_event_t *motion_notify;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -0500548 xcb_enter_notify_event_t *enter_notify;
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400549 xcb_key_press_event_t *key_press, *key_release;
Kristian Høgsberg3ba48582011-01-27 11:57:19 -0500550 xcb_keymap_notify_event_t *keymap_notify;
551 xcb_focus_in_event_t *focus_in;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400552 xcb_atom_t atom;
Kristian Høgsberg3ba48582011-01-27 11:57:19 -0500553 uint32_t *k;
554 int i, set;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400555
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400556 prev = NULL;
Kristian Høgsberg127d0f02011-04-22 12:18:13 -0400557 while (x11_compositor_next_event(c, &event, mask)) {
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400558 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 Ryazanovc2247482011-08-16 17:25:32 -0700563 key_release->time == key_press->time &&
564 key_release->detail == key_press->detail) {
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400565 /* 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øgsberg025f7b82011-04-19 12:38:22 -0400574 * event below. */
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400575 notify_key(c->base.input_device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500576 weston_compositor_get_time(),
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400577 key_release->detail - 8, 0);
578 free(prev);
579 prev = NULL;
580 break;
581 }
Kristian Høgsberg025f7b82011-04-19 12:38:22 -0400582
583 case XCB_FOCUS_IN:
Kristian Høgsberg025f7b82011-04-19 12:38:22 -0400584 /* 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øgsberg8334bc12012-01-03 10:29:47 -0500599 weston_compositor_get_time(),
Kristian Høgsberg025f7b82011-04-19 12:38:22 -0400600 &output->base, &c->keys);
601
602 free(prev);
603 prev = NULL;
604 break;
605
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400606 default:
607 /* No previous event held */
608 break;
Kristian Høgsberg3ddd1482011-04-15 15:48:07 -0400609 }
610
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400611 switch (event->response_type & ~0x80) {
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400612 case XCB_KEY_PRESS:
613 key_press = (xcb_key_press_event_t *) event;
614 notify_key(c->base.input_device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500615 weston_compositor_get_time(),
Kristian Høgsberg293af262011-10-11 17:23:02 -0400616 key_press->detail - 8, 1);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400617 break;
618 case XCB_KEY_RELEASE:
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400619 prev = event;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400620 break;
621 case XCB_BUTTON_PRESS:
Tiago Vignattia3a71622011-12-08 17:03:17 +0200622 x11_compositor_deliver_button_event(c, event, 1);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400623 break;
624 case XCB_BUTTON_RELEASE:
Tiago Vignattia3a71622011-12-08 17:03:17 +0200625 x11_compositor_deliver_button_event(c, event, 0);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400626 break;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400627 case XCB_MOTION_NOTIFY:
628 motion_notify = (xcb_motion_notify_event_t *) event;
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700629 output = x11_compositor_find_output(c, motion_notify->event);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400630 notify_motion(c->base.input_device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500631 weston_compositor_get_time(),
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700632 output->base.x + motion_notify->event_x,
633 output->base.y + motion_notify->event_y);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400634 break;
635
636 case XCB_EXPOSE:
Benjamin Franzke84290d02011-03-02 10:07:59 +0100637 /* FIXME: schedule output repaint */
638 /* output = x11_compositor_find_output(c, expose->window); */
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400639
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500640 weston_compositor_schedule_repaint(&c->base);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400641 break;
Kristian Høgsberg86e09892010-07-07 09:51:11 -0400642
643 case XCB_ENTER_NOTIFY:
Kristian Høgsberg93331ff2011-01-26 20:35:07 -0500644 enter_notify = (xcb_enter_notify_event_t *) event;
Kristian Høgsberg2dfe6262011-02-08 11:59:53 -0500645 if (enter_notify->state >= Button1Mask)
646 break;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -0500647 output = x11_compositor_find_output(c, enter_notify->event);
648 notify_pointer_focus(c->base.input_device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500649 weston_compositor_get_time(),
Kristian Høgsberg93331ff2011-01-26 20:35:07 -0500650 &output->base,
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700651 output->base.x + enter_notify->event_x,
652 output->base.y + enter_notify->event_y);
Kristian Høgsberg86e09892010-07-07 09:51:11 -0400653 break;
654
655 case XCB_LEAVE_NOTIFY:
Kristian Høgsberg93331ff2011-01-26 20:35:07 -0500656 enter_notify = (xcb_enter_notify_event_t *) event;
Kristian Høgsberg2dfe6262011-02-08 11:59:53 -0500657 if (enter_notify->state >= Button1Mask)
658 break;
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700659 output = x11_compositor_find_output(c, enter_notify->event);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -0500660 notify_pointer_focus(c->base.input_device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500661 weston_compositor_get_time(),
Kristian Høgsberg93331ff2011-01-26 20:35:07 -0500662 NULL,
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700663 output->base.x + enter_notify->event_x,
664 output->base.y + enter_notify->event_y);
Kristian Høgsberg86e09892010-07-07 09:51:11 -0400665 break;
666
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400667 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øgsberg50dc6982010-12-01 16:43:56 -0500671 wl_display_terminate(c->base.wl_display);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400672 break;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400673
Kristian Høgsberg3ba48582011-01-27 11:57:19 -0500674 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øgsberg025f7b82011-04-19 12:38:22 -0400679 prev = event;
Kristian Høgsberg3ba48582011-01-27 11:57:19 -0500680 break;
681
682 case XCB_FOCUS_OUT:
683 focus_in = (xcb_focus_in_event_t *) event;
Kristian Høgsberg42e40ae2011-12-19 14:36:50 -0500684 if (focus_in->mode == XCB_NOTIFY_MODE_WHILE_GRABBED ||
685 focus_in->mode == XCB_NOTIFY_MODE_UNGRAB)
Kristian Høgsberg3ba48582011-01-27 11:57:19 -0500686 break;
687 notify_keyboard_focus(c->base.input_device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500688 weston_compositor_get_time(),
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400689 NULL, NULL);
Kristian Høgsberg3ba48582011-01-27 11:57:19 -0500690 break;
691
Kristian Høgsberg3ba48582011-01-27 11:57:19 -0500692 default:
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400693 break;
694 }
695
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400696 if (prev != event)
Kristian Høgsberg3ddd1482011-04-15 15:48:07 -0400697 free (event);
698 }
699
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400700 switch (prev ? prev->response_type & ~0x80 : 0x80) {
701 case XCB_KEY_RELEASE:
702 key_release = (xcb_key_press_event_t *) prev;
Kristian Høgsberg3ddd1482011-04-15 15:48:07 -0400703 notify_key(c->base.input_device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500704 weston_compositor_get_time(),
Kristian Høgsberg293af262011-10-11 17:23:02 -0400705 key_release->detail - 8, 0);
Kristian Høgsberg94da7e12011-04-19 09:23:29 -0400706 free(prev);
707 prev = NULL;
708 break;
709 default:
710 break;
Kristian Høgsberg3ba48582011-01-27 11:57:19 -0500711 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400712
Kristian Høgsberg127d0f02011-04-22 12:18:13 -0400713 return event != NULL;
Kristian Høgsbergee724822011-04-21 14:51:44 -0400714}
715
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400716#define F(field) offsetof(struct x11_compositor, field)
717
718static void
719x11_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øgsberg24ed6212011-01-26 14:02:31 -0500726 { "WM_CLASS", F(atom.wm_class) },
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400727 { "_NET_WM_NAME", F(atom.net_wm_name) },
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500728 { "_NET_WM_ICON", F(atom.net_wm_icon) },
Kristian Høgsberg83eeacb2011-06-18 04:20:54 -0400729 { "_NET_WM_STATE", F(atom.net_wm_state) },
730 { "_NET_WM_STATE_FULLSCREEN", F(atom.net_wm_state_fullscreen) },
Kristian Høgsberg24ed6212011-01-26 14:02:31 -0500731 { "STRING", F(atom.string) },
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400732 { "UTF8_STRING", F(atom.utf8_string) },
Kristian Høgsbergf58d8ca2011-01-26 14:37:07 -0500733 { "CARDINAL", F(atom.cardinal) },
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400734 };
735
Kristian Høgsberg09e26922011-12-23 13:33:45 -0500736 xcb_intern_atom_cookie_t cookies[ARRAY_LENGTH(atoms)];
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400737 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øgsberg09e26922011-12-23 13:33:45 -0500743 for (i = 0; i < ARRAY_LENGTH(atoms); i++)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400744 cookies[i] = xcb_intern_atom (c->conn, 0,
745 strlen(atoms[i].name),
746 atoms[i].name);
747
Kristian Høgsberg09e26922011-12-23 13:33:45 -0500748 for (i = 0; i < ARRAY_LENGTH(atoms); i++) {
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400749 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øgsbergcaa64422010-12-01 16:52:15 -0500767static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500768x11_destroy(struct weston_compositor *ec)
Kristian Høgsbergcaa64422010-12-01 16:52:15 -0500769{
Pekka Paalanen43c61d82012-01-03 11:58:34 +0200770 struct x11_compositor *compositor = (struct x11_compositor *)ec;
Matt Roper361d2ad2011-08-29 13:52:23 -0700771
Pekka Paalanen43c61d82012-01-03 11:58:34 +0200772 wl_event_source_remove(compositor->xcb_source);
773 x11_input_destroy(compositor);
774
Kristian Høgsberg3466bc82012-01-03 11:29:15 -0500775 weston_compositor_shutdown(ec); /* destroys outputs, too */
Pekka Paalanen43c61d82012-01-03 11:58:34 +0200776
777 x11_compositor_fini_egl(compositor);
778
779 XCloseDisplay(compositor->dpy);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -0500780 free(ec);
781}
782
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500783static struct weston_compositor *
Kristian Høgsberg83eeacb2011-06-18 04:20:54 -0400784x11_compositor_create(struct wl_display *display,
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700785 int width, int height, int count, int fullscreen)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400786{
787 struct x11_compositor *c;
788 struct wl_event_loop *loop;
789 xcb_screen_iterator_t s;
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700790 int i, x;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400791
792 c = malloc(sizeof *c);
793 if (c == NULL)
794 return NULL;
795
796 memset(c, 0, sizeof *c);
Benjamin Franzke3b288af2011-02-20 19:58:42 +0100797
798 c->dpy = XOpenDisplay(NULL);
Cyril Brulebois20798292011-04-06 18:05:40 +0200799 if (c->dpy == NULL)
800 return NULL;
801
Benjamin Franzke3b288af2011-02-20 19:58:42 +0100802 c->conn = XGetXCBConnection(c->dpy);
Benjamin Franzkee997c5f2011-03-25 14:06:37 +0100803 XSetEventQueueOwner(c->dpy, XCBOwnsEventQueue);
804
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400805 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øgsberg3ba48582011-01-27 11:57:19 -0500810 wl_array_init(&c->keys);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400811
812 x11_compositor_get_resources(c);
813
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -0400814 c->base.wl_display = display;
Tiago Vignatti997ce642010-11-10 02:42:35 +0200815 if (x11_compositor_init_egl(c) < 0)
Darxus55973f22010-11-22 21:24:39 -0500816 return NULL;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400817
Kristian Høgsberg8525a502011-01-14 16:20:21 -0500818 c->base.destroy = x11_destroy;
Kristian Høgsberg8525a502011-01-14 16:20:21 -0500819
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400820 /* Can't init base class until we have a current egl context */
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500821 if (weston_compositor_init(&c->base, display) < 0)
Kristian Høgsberga9468212010-06-14 21:03:11 -0400822 return NULL;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400823
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700824 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øgsbergce5325d2010-06-14 11:54:00 -0400830
Darxus55973f22010-11-22 21:24:39 -0500831 if (x11_input_create(c) < 0)
832 return NULL;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400833
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øgsberg127d0f02011-04-22 12:18:13 -0400840 wl_event_source_check(c->xcb_source);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400841
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400842 return &c->base;
843}
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400844
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500845struct weston_compositor *
Kristian Høgsberg6c709a32011-05-06 14:52:41 -0400846backend_init(struct wl_display *display, char *options);
847
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500848WL_EXPORT struct weston_compositor *
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400849backend_init(struct wl_display *display, char *options)
850{
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700851 int width = 1024, height = 640, fullscreen = 0, count = 1, i;
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400852 char *p, *value;
853
Kristian Høgsberg83eeacb2011-06-18 04:20:54 -0400854 static char * const tokens[] = {
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700855 "width", "height", "fullscreen", "output-count", NULL
Kristian Høgsberg83eeacb2011-06-18 04:20:54 -0400856 };
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400857
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øgsberg83eeacb2011-06-18 04:20:54 -0400867 case 2:
868 fullscreen = 1;
869 break;
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700870 case 3:
871 count = strtol(value, NULL, 0);
872 break;
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400873 }
874 }
875
Kristian Høgsberg1ccd9d22011-07-21 10:22:13 -0700876 return x11_compositor_create(display,
877 width, height, count, fullscreen);
Kristian Høgsberg1c562182011-05-02 22:09:20 -0400878}