blob: b24d4f22d2e8ca5a477fa1c9250513cc2aaef1be [file] [log] [blame]
Kristian Høgsbergffd710e2008-12-02 15:15:01 -05001/*
2 * Copyright © 2008 Kristian Høgsberg
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that copyright
7 * notice and this permission notice appear in supporting documentation, and
8 * that the name of the copyright holders not be used in advertising or
9 * publicity pertaining to distribution of the software without specific,
10 * written prior permission. The copyright holders make no representations
11 * about the suitability of this software for any purpose. It is provided "as
12 * is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20 * OF THIS SOFTWARE.
21 */
22
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040023#include <stdio.h>
24#include <string.h>
25#include <stdlib.h>
26#include <stdint.h>
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -050027#include <stdarg.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040028#include <i915_drm.h>
29#include <sys/ioctl.h>
30#include <sys/mman.h>
31#include <fcntl.h>
32#include <unistd.h>
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -050033#include <signal.h>
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -050034#include <cairo.h>
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -050035#include <gdk-pixbuf/gdk-pixbuf.h>
36#include <glib.h>
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -050037#include <sys/poll.h>
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -050038#include <png.h>
Kristian Høgsberg54879822008-11-23 17:07:32 -050039#include <math.h>
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -050040#include <linux/input.h>
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -050041#include <xf86drmMode.h>
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -050042#include <time.h>
Kristian Høgsbergc492b482008-12-12 12:00:02 -050043#include <fnmatch.h>
44#include <dirent.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040045
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040046#include <GL/gl.h>
47#include <eagle.h>
48
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050049#include "wayland.h"
50#include "cairo-util.h"
51#include "egl-compositor.h"
52
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040053#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])
54
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -050055struct wl_visual {
56 struct wl_object base;
57};
58
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050059struct egl_input_device {
60 struct wl_object base;
61 int32_t x, y;
62 struct egl_compositor *ec;
Kristian Høgsberg29573bc2008-12-11 23:27:27 -050063 struct egl_surface *pointer_surface;
Kristian Høgsbergc492b482008-12-12 12:00:02 -050064 struct wl_list link;
Kristian Høgsberg29573bc2008-12-11 23:27:27 -050065
66 int grab;
67 struct egl_surface *grab_surface;
Kristian Høgsberga7700c82008-12-12 13:48:30 -050068 struct egl_surface *focus_surface;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050069};
70
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040071struct egl_compositor {
72 struct wl_compositor base;
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -050073 struct wl_visual argb_visual, premultiplied_argb_visual, rgb_visual;
74
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040075 EGLDisplay display;
76 EGLSurface surface;
77 EGLContext context;
Kristian Høgsberg2d9cd1e2008-11-03 08:09:34 -050078 EGLConfig config;
Kristian Høgsbergf9212892008-10-11 18:40:23 -040079 struct wl_display *wl_display;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040080 int gem_fd;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -050081 int width, height;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -050082 struct egl_surface *background;
Kristian Høgsberg54879822008-11-23 17:07:32 -050083 struct egl_surface *overlay;
Kristian Høgsberg5c1e6ec2008-11-25 13:51:36 -050084 double overlay_y, overlay_target, overlay_previous;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -050085
Kristian Høgsbergc492b482008-12-12 12:00:02 -050086 struct wl_list input_device_list;
Kristian Høgsberg201a9042008-12-10 00:40:50 -050087 struct wl_list surface_list;
88
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -050089 /* Repaint state. */
90 struct wl_event_source *timer_source;
91 int repaint_needed;
92 int repaint_on_timeout;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -050093 struct timespec previous_swap;
94 uint32_t current_frame;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040095};
96
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -050097struct egl_surface {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -050098 struct wl_surface base;
99 struct egl_compositor *compositor;
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500100 struct wl_visual *visual;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400101 GLuint texture;
Kristian Høgsbergf9212892008-10-11 18:40:23 -0400102 struct wl_map map;
Kristian Høgsberg2d9cd1e2008-11-03 08:09:34 -0500103 EGLSurface surface;
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500104 int width, height;
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500105 struct wl_list link;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400106};
107
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500108struct screenshooter {
109 struct wl_object base;
110 struct egl_compositor *ec;
111};
112
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500113struct screenshooter_interface {
114 void (*shoot)(struct wl_client *client, struct screenshooter *shooter);
115};
116
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -0500117static void
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500118screenshooter_shoot(struct wl_client *client, struct screenshooter *shooter)
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -0500119{
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500120 struct egl_compositor *ec = shooter->ec;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -0500121 GLuint stride;
122 static const char filename[] = "wayland-screenshot.png";
Kristian Høgsberg0ea47102008-12-14 15:53:13 -0500123 GdkPixbuf *pixbuf;
124 GError *error = NULL;
125 void *data;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -0500126
127 data = eglReadBuffer(ec->display, ec->surface, GL_FRONT_LEFT, &stride);
Kristian Høgsberg0ea47102008-12-14 15:53:13 -0500128 pixbuf = gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB, TRUE,
129 8, ec->width, ec->height, stride,
130 NULL, NULL);
131 gdk_pixbuf_save(pixbuf, filename, "png", &error, NULL);
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -0500132}
133
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500134static const struct wl_method screenshooter_methods[] = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500135 { "shoot", "", NULL }
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500136};
137
138static const struct wl_interface screenshooter_interface = {
139 "screenshooter", 1,
140 ARRAY_LENGTH(screenshooter_methods),
141 screenshooter_methods,
142};
143
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500144struct screenshooter_interface screenshooter_implementation = {
145 screenshooter_shoot
146};
147
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500148static struct screenshooter *
149screenshooter_create(struct egl_compositor *ec)
150{
151 struct screenshooter *shooter;
152
153 shooter = malloc(sizeof *shooter);
154 if (shooter == NULL)
155 return NULL;
156
157 shooter->base.interface = &screenshooter_interface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500158 shooter->base.implementation = (void(**)(void)) &screenshooter_implementation;
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500159 shooter->ec = ec;
160
161 return shooter;
162};
163
Kristian Høgsberg54879822008-11-23 17:07:32 -0500164static struct egl_surface *
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500165egl_surface_create_from_cairo_surface(struct egl_compositor *ec,
166 cairo_surface_t *surface,
Kristian Høgsberg54879822008-11-23 17:07:32 -0500167 int x, int y, int width, int height)
168{
169 struct egl_surface *es;
170 int stride;
171 void *data;
172
173 stride = cairo_image_surface_get_stride(surface);
174 data = cairo_image_surface_get_data(surface);
175
176 es = malloc(sizeof *es);
177 if (es == NULL)
178 return NULL;
179
180 glGenTextures(1, &es->texture);
181 glBindTexture(GL_TEXTURE_2D, es->texture);
182 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
Kristian Høgsberg98fed0f2008-12-09 13:35:35 -0500183 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_REPEAT);
184 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
185 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500186 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
187 GL_BGRA, GL_UNSIGNED_BYTE, data);
188
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500189 es->compositor = ec;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500190 es->map.x = x;
191 es->map.y = y;
192 es->map.width = width;
193 es->map.height = height;
194 es->surface = EGL_NO_SURFACE;
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500195 es->visual = &ec->premultiplied_argb_visual;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500196
197 return es;
198}
199
200static void
201egl_surface_destroy(struct egl_surface *es, struct egl_compositor *ec)
202{
203 glDeleteTextures(1, &es->texture);
204 if (es->surface != EGL_NO_SURFACE)
205 eglDestroySurface(ec->display, es->surface);
206 free(es);
207}
208
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400209static void
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500210pointer_path(cairo_t *cr, int x, int y)
211{
212 const int end = 3, tx = 4, ty = 12, dx = 5, dy = 10;
213 const int width = 16, height = 16;
214
215 cairo_move_to(cr, x, y);
216 cairo_line_to(cr, x + tx, y + ty);
217 cairo_line_to(cr, x + dx, y + dy);
218 cairo_line_to(cr, x + width - end, y + height);
219 cairo_line_to(cr, x + width, y + height - end);
220 cairo_line_to(cr, x + dy, y + dx);
221 cairo_line_to(cr, x + ty, y + tx);
222 cairo_close_path(cr);
223}
224
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500225static struct egl_surface *
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500226pointer_create(struct egl_compositor *ec, int x, int y, int width, int height)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500227{
Kristian Høgsberg54879822008-11-23 17:07:32 -0500228 struct egl_surface *es;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500229 const int hotspot_x = 16, hotspot_y = 16;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500230 cairo_surface_t *surface;
231 cairo_t *cr;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500232
233 surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
234 width, height);
235
236 cr = cairo_create(surface);
237 pointer_path(cr, hotspot_x + 5, hotspot_y + 4);
238 cairo_set_line_width (cr, 2);
239 cairo_set_source_rgb(cr, 0, 0, 0);
240 cairo_stroke_preserve(cr);
241 cairo_fill(cr);
242 blur_surface(surface, width);
243
244 pointer_path(cr, hotspot_x, hotspot_y);
245 cairo_stroke_preserve(cr);
246 cairo_set_source_rgb(cr, 1, 1, 1);
247 cairo_fill(cr);
248 cairo_destroy(cr);
249
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500250 es = egl_surface_create_from_cairo_surface(ec,
251 surface,
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500252 x - hotspot_x,
253 y - hotspot_y,
254 width, height);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500255
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500256 cairo_surface_destroy(surface);
257
Kristian Høgsberg54879822008-11-23 17:07:32 -0500258 return es;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500259}
260
261static struct egl_surface *
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500262background_create(struct egl_compositor *ec,
263 const char *filename, int width, int height)
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500264{
265 struct egl_surface *background;
266 GdkPixbuf *pixbuf;
267 GError *error = NULL;
268 int pixbuf_width, pixbuf_height;
269 void *data;
270
271 background = malloc(sizeof *background);
272 if (background == NULL)
273 return NULL;
274
275 g_type_init();
276
277 pixbuf = gdk_pixbuf_new_from_file(filename, &error);
278 if (error != NULL) {
279 free(background);
280 return NULL;
281 }
282
283 pixbuf_width = gdk_pixbuf_get_width(pixbuf);
284 pixbuf_height = gdk_pixbuf_get_height(pixbuf);
285 data = gdk_pixbuf_get_pixels(pixbuf);
286
287 glGenTextures(1, &background->texture);
288 glBindTexture(GL_TEXTURE_2D, background->texture);
289 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
Kristian Høgsberg98fed0f2008-12-09 13:35:35 -0500290 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_REPEAT);
291 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
292 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500293 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, pixbuf_width, pixbuf_height, 0,
294 GL_BGR, GL_UNSIGNED_BYTE, data);
295
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500296 background->compositor = ec;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500297 background->map.x = 0;
298 background->map.y = 0;
299 background->map.width = width;
300 background->map.height = height;
301 background->surface = EGL_NO_SURFACE;
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500302 background->visual = &ec->rgb_visual;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500303
304 return background;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500305}
306
307static void
Kristian Høgsberg54879822008-11-23 17:07:32 -0500308rounded_rect(cairo_t *cr, int x0, int y0, int x1, int y1, int radius)
309{
310 cairo_move_to(cr, x0, y0 + radius);
311 cairo_arc(cr, x0 + radius, y0 + radius, radius, M_PI, 3 * M_PI / 2);
312 cairo_line_to(cr, x1 - radius, y0);
313 cairo_arc(cr, x1 - radius, y0 + radius, radius, 3 * M_PI / 2, 2 * M_PI);
314 cairo_line_to(cr, x1, y1 - radius);
315 cairo_arc(cr, x1 - radius, y1 - radius, radius, 0, M_PI / 2);
316 cairo_line_to(cr, x0 + radius, y1);
317 cairo_arc(cr, x0 + radius, y1 - radius, radius, M_PI / 2, M_PI);
318 cairo_close_path(cr);
319}
320
321static void
322draw_button(cairo_t *cr, int x, int y, int width, int height, const char *text)
323{
324 cairo_pattern_t *gradient;
325 cairo_text_extents_t extents;
326 double bright = 0.15, dim = 0.02;
327 int radius = 10;
328
329 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
330 cairo_set_line_width (cr, 2);
331 rounded_rect(cr, x, y, x + width, y + height, radius);
332 cairo_set_source_rgb(cr, dim, dim, dim);
333 cairo_stroke(cr);
334 rounded_rect(cr, x + 2, y + 2, x + width, y + height, radius);
335 cairo_set_source_rgb(cr, 0.1, 0.1, 0.1);
336 cairo_stroke(cr);
337
338 rounded_rect(cr, x + 1, y + 1, x + width - 1, y + height - 1, radius - 1);
339 cairo_set_source_rgb(cr, bright, bright, bright);
340 cairo_stroke(cr);
341 rounded_rect(cr, x + 3, y + 3, x + width - 1, y + height - 1, radius - 1);
342 cairo_set_source_rgb(cr, dim, dim, dim);
343 cairo_stroke(cr);
344
345 rounded_rect(cr, x + 1, y + 1, x + width - 1, y + height - 1, radius - 1);
346 gradient = cairo_pattern_create_linear (0, y, 0, y + height);
347 cairo_pattern_add_color_stop_rgb(gradient, 0, 0.15, 0.15, 0.15);
348 cairo_pattern_add_color_stop_rgb(gradient, 0.5, 0.08, 0.08, 0.08);
349 cairo_pattern_add_color_stop_rgb(gradient, 0.5, 0.07, 0.07, 0.07);
350 cairo_pattern_add_color_stop_rgb(gradient, 1, 0.1, 0.1, 0.1);
351 cairo_set_source(cr, gradient);
352 cairo_fill(cr);
353
354 cairo_set_font_size(cr, 16);
355 cairo_text_extents(cr, text, &extents);
356 cairo_move_to(cr, x + (width - extents.width) / 2, y + (height - extents.height) / 2 - extents.y_bearing);
357 cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
358 cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
359 cairo_set_line_width (cr, 4);
360 cairo_text_path(cr, text);
361 cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
362 cairo_stroke_preserve(cr);
363 cairo_set_source_rgb(cr, 1, 1, 1);
364 cairo_fill(cr);
365}
366
367static struct egl_surface *
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500368overlay_create(struct egl_compositor *ec, int x, int y, int width, int height)
Kristian Høgsberg54879822008-11-23 17:07:32 -0500369{
370 struct egl_surface *es;
371 cairo_surface_t *surface;
372 cairo_t *cr;
373 int total_width, button_x, button_y;
374 const int button_width = 150;
375 const int button_height = 40;
376 const int spacing = 50;
377
378 surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
379 width, height);
380
381 cr = cairo_create(surface);
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500382 cairo_set_source_rgba(cr, 0.1, 0.1, 0.1, 0.8);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500383 cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
384 cairo_paint(cr);
385
386 total_width = button_width * 2 + spacing;
387 button_x = (width - total_width) / 2;
388 button_y = height - button_height - 20;
389 draw_button(cr, button_x, button_y, button_width, button_height, "Previous");
390 button_x += button_width + spacing;
391 draw_button(cr, button_x, button_y, button_width, button_height, "Next");
392
393 cairo_destroy(cr);
394
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500395 es = egl_surface_create_from_cairo_surface(ec, surface,
396 x, y, width, height);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500397
398 cairo_surface_destroy(surface);
399
400 return es;
401}
402
403static void
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500404draw_surface(struct egl_surface *es)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500405{
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500406 struct egl_compositor *ec = es->compositor;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500407 GLint vertices[12];
408 GLint tex_coords[12] = { 0, 0, 0, 1, 1, 0, 1, 1 };
409 GLuint indices[4] = { 0, 1, 2, 3 };
410
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500411 vertices[0] = es->map.x;
412 vertices[1] = es->map.y;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500413 vertices[2] = 0;
414
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500415 vertices[3] = es->map.x;
416 vertices[4] = es->map.y + es->map.height;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500417 vertices[5] = 0;
418
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500419 vertices[6] = es->map.x + es->map.width;
420 vertices[7] = es->map.y;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500421 vertices[8] = 0;
422
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500423 vertices[9] = es->map.x + es->map.width;
424 vertices[10] = es->map.y + es->map.height;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500425 vertices[11] = 0;
426
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500427 if (es->visual == &ec->argb_visual) {
428 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
429 glEnable(GL_BLEND);
430 } else if (es->visual == &ec->premultiplied_argb_visual) {
431 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
432 glEnable(GL_BLEND);
433 } else {
434 glDisable(GL_BLEND);
435 }
436
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500437 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500438 glEnable(GL_TEXTURE_2D);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500439 glEnableClientState(GL_VERTEX_ARRAY);
440 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
441 glVertexPointer(3, GL_INT, 0, vertices);
442 glTexCoordPointer(2, GL_INT, 0, tex_coords);
443 glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_INT, indices);
444}
445
446static void
Kristian Høgsberg9af92b32008-11-24 01:12:46 -0500447schedule_repaint(struct egl_compositor *ec);
448
449static void
Kristian Høgsberg5c1e6ec2008-11-25 13:51:36 -0500450animate_overlay(struct egl_compositor *ec)
451{
452 double force, y;
453 int32_t top, bottom;
Kristian Høgsbergffb74062008-11-25 18:10:39 -0500454#if 1
455 double bounce = 0.0;
456 double friction = 1.0;
457 double spring = 0.2;
458#else
459 double bounce = 0.2;
460 double friction = 0.04;
461 double spring = 0.09;
462#endif
Kristian Høgsberg5c1e6ec2008-11-25 13:51:36 -0500463
464 y = ec->overlay_y;
Kristian Høgsbergffb74062008-11-25 18:10:39 -0500465 force = (ec->overlay_target - ec->overlay_y) * spring +
466 (ec->overlay_previous - y) * friction;
Kristian Høgsberg5c1e6ec2008-11-25 13:51:36 -0500467
468 ec->overlay_y = y + (y - ec->overlay_previous) + force;
469 ec->overlay_previous = y;
470
471 top = ec->height - ec->overlay->map.height;
472 bottom = ec->height;
473 if (ec->overlay_y >= bottom) {
474 ec->overlay_y = bottom;
475 ec->overlay_previous = bottom;
476 }
477
478 if (ec->overlay_y <= top) {
Kristian Høgsbergffb74062008-11-25 18:10:39 -0500479 ec->overlay_y = top + bounce * (top - ec->overlay_y);
480 ec->overlay_previous =
481 top + bounce * (top - ec->overlay_previous);
Kristian Høgsberg5c1e6ec2008-11-25 13:51:36 -0500482 }
483
484 ec->overlay->map.y = ec->overlay_y + 0.5;
Kristian Høgsbergffb74062008-11-25 18:10:39 -0500485
Kristian Høgsberg73c30582008-11-25 22:45:46 -0500486 if (fabs(y - ec->overlay_target) > 0.2 ||
487 fabs(ec->overlay_y - ec->overlay_target) > 0.2)
Kristian Høgsberg5c1e6ec2008-11-25 13:51:36 -0500488 schedule_repaint(ec);
489}
490
491static void
Kristian Høgsberg4a298902008-11-28 18:35:25 -0500492repaint(void *data)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400493{
494 struct egl_compositor *ec = data;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500495 struct egl_surface *es;
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500496 struct egl_input_device *eid;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500497 struct timespec ts;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500498 uint32_t msecs;
499
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500500 if (!ec->repaint_needed) {
501 ec->repaint_on_timeout = 0;
502 return;
503 }
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500504
Kristian Høgsberg5b7f8322008-12-18 12:08:19 -0500505 if (ec->background)
506 draw_surface(ec->background);
507 else
508 glClear(GL_COLOR_BUFFER_BIT);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400509
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500510 es = container_of(ec->surface_list.next,
511 struct egl_surface, link);
512 while (&es->link != &ec->surface_list) {
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500513 draw_surface(es);
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500514
515 es = container_of(es->link.next,
516 struct egl_surface, link);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400517 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400518
Kristian Høgsberg54879822008-11-23 17:07:32 -0500519 draw_surface(ec->overlay);
520
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500521 eid = container_of(ec->input_device_list.next,
522 struct egl_input_device, link);
523 while (&eid->link != &ec->input_device_list) {
524 draw_surface(eid->pointer_surface);
525
526 eid = container_of(eid->link.next,
527 struct egl_input_device, link);
528 }
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500529
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400530 eglSwapBuffers(ec->display, ec->surface);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500531 ec->repaint_needed = 0;
Kristian Høgsberg9af92b32008-11-24 01:12:46 -0500532
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500533 clock_gettime(CLOCK_MONOTONIC, &ts);
534 msecs = ts.tv_sec * 1000 + ts.tv_nsec / (1000 * 1000);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500535 wl_display_post_frame(ec->wl_display, &ec->base,
536 ec->current_frame, msecs);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500537 ec->current_frame++;
538
Kristian Høgsberg4a298902008-11-28 18:35:25 -0500539 wl_event_source_timer_update(ec->timer_source, 10);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500540 ec->repaint_on_timeout = 1;
Kristian Høgsberg44f36e32008-11-26 12:57:31 -0500541
Kristian Høgsberg5c1e6ec2008-11-25 13:51:36 -0500542 animate_overlay(ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400543}
544
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500545static void
546schedule_repaint(struct egl_compositor *ec)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400547{
548 struct wl_event_loop *loop;
549
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500550 ec->repaint_needed = 1;
551 if (!ec->repaint_on_timeout) {
552 loop = wl_display_get_event_loop(ec->wl_display);
Kristian Høgsberg4a298902008-11-28 18:35:25 -0500553 wl_event_loop_add_idle(loop, repaint, ec);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500554 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400555}
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400556
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500557static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500558surface_destroy(struct wl_client *client,
559 struct wl_surface *surface)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400560{
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500561 struct egl_surface *es = (struct egl_surface *) surface;
562 struct egl_compositor *ec = es->compositor;
Kristian Høgsberg2d9cd1e2008-11-03 08:09:34 -0500563
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500564 wl_list_remove(&es->link);
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500565 egl_surface_destroy(es, ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400566
567 schedule_repaint(ec);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400568}
569
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500570static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500571surface_attach(struct wl_client *client,
572 struct wl_surface *surface, uint32_t name,
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500573 uint32_t width, uint32_t height, uint32_t stride,
574 struct wl_object *visual)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400575{
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500576 struct egl_surface *es = (struct egl_surface *) surface;
577 struct egl_compositor *ec = es->compositor;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400578
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500579 if (es->surface != EGL_NO_SURFACE)
580 eglDestroySurface(ec->display, es->surface);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400581
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500582 es->width = width;
583 es->height = height;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500584 es->surface = eglCreateSurfaceForName(ec->display, ec->config,
Kristian Høgsberg78231c82008-11-08 15:06:01 -0500585 name, width, height, stride, NULL);
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500586 if (visual == &ec->argb_visual.base)
587 es->visual = &ec->argb_visual;
588 else if (visual == &ec->premultiplied_argb_visual.base)
589 es->visual = &ec->premultiplied_argb_visual;
Kristian Høgsberge10b8282008-12-18 19:58:44 -0500590 else if (visual == &ec->rgb_visual.base)
591 es->visual = &ec->rgb_visual;
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500592 else
593 /* FIXME: Smack client with an exception event */;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400594
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500595 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400596 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
Kristian Høgsberg98fed0f2008-12-09 13:35:35 -0500597 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_REPEAT);
598 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
599 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500600 eglBindTexImage(ec->display, es->surface, GL_TEXTURE_2D);
Kristian Høgsbergf9212892008-10-11 18:40:23 -0400601}
602
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500603static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500604surface_map(struct wl_client *client,
605 struct wl_surface *surface,
606 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400607{
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500608 struct egl_surface *es = (struct egl_surface *) surface;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400609
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500610 es->map.x = x;
611 es->map.y = y;
612 es->map.width = width;
613 es->map.height = height;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400614}
615
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500616static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500617surface_copy(struct wl_client *client,
618 struct wl_surface *surface,
619 int32_t dst_x, int32_t dst_y,
620 uint32_t name, uint32_t stride,
621 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500622{
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500623 struct egl_surface *es = (struct egl_surface *) surface;
624 struct egl_compositor *ec = es->compositor;
Kristian Høgsberg78231c82008-11-08 15:06:01 -0500625 EGLSurface src;
Kristian Høgsberg78231c82008-11-08 15:06:01 -0500626
627 /* FIXME: glCopyPixels should work, but then we'll have to
628 * call eglMakeCurrent to set up the src and dest surfaces
629 * first. This seems cheaper, but maybe there's a better way
630 * to accomplish this. */
631
632 src = eglCreateSurfaceForName(ec->display, ec->config,
633 name, x + width, y + height, stride, NULL);
634
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500635 eglCopyNativeBuffers(ec->display, es->surface, GL_FRONT_LEFT, dst_x, dst_y,
Kristian Høgsberg78231c82008-11-08 15:06:01 -0500636 src, GL_FRONT_LEFT, x, y, width, height);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500637 eglDestroySurface(ec->display, src);
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500638}
639
640static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500641surface_damage(struct wl_client *client,
642 struct wl_surface *surface,
643 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500644{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500645 /* FIXME: This need to take a damage region, of course. */
646}
647
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500648const static struct wl_surface_interface surface_interface = {
649 surface_destroy,
650 surface_attach,
651 surface_map,
652 surface_copy,
653 surface_damage
654};
655
656static void
657compositor_create_surface(struct wl_client *client,
658 struct wl_compositor *compositor, uint32_t id)
659{
660 struct egl_compositor *ec = (struct egl_compositor *) compositor;
661 struct egl_surface *es;
662
663 es = malloc(sizeof *es);
664 if (es == NULL)
665 /* FIXME: Send OOM event. */
666 return;
667
668 es->compositor = ec;
669 es->surface = EGL_NO_SURFACE;
670 wl_list_insert(ec->surface_list.prev, &es->link);
671 glGenTextures(1, &es->texture);
672 wl_client_add_surface(client, &es->base,
673 &surface_interface, id);
674}
675
676static void
677compositor_commit(struct wl_client *client,
678 struct wl_compositor *compositor, uint32_t key)
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500679{
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500680 struct egl_compositor *ec = (struct egl_compositor *) compositor;
681
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500682 schedule_repaint(ec);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500683 wl_client_send_acknowledge(client, compositor, key, ec->current_frame);
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500684}
685
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500686const static struct wl_compositor_interface compositor_interface = {
687 compositor_create_surface,
688 compositor_commit
689};
690
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500691static struct egl_surface *
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500692pick_surface(struct egl_input_device *device)
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500693{
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500694 struct egl_compositor *ec = device->ec;
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500695 struct egl_surface *es;
696
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500697 if (device->grab > 0)
698 return device->grab_surface;
699
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500700 es = container_of(ec->surface_list.prev,
701 struct egl_surface, link);
702 while (&es->link != &ec->surface_list) {
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500703 if (es->map.x <= device->x &&
704 device->x < es->map.x + es->map.width &&
705 es->map.y <= device->y &&
706 device->y < es->map.y + es->map.height)
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500707 return es;
708
709 es = container_of(es->link.prev,
710 struct egl_surface, link);
711 }
712
713 return NULL;
714}
715
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500716void
717notify_motion(struct egl_input_device *device, int x, int y)
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500718{
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500719 struct egl_surface *es;
720 const int hotspot_x = 16, hotspot_y = 16;
721 int32_t sx, sy;
722
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500723 es = pick_surface(device);
Kristian Høgsberg29573bc2008-12-11 23:27:27 -0500724
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500725 if (es) {
726 sx = (x - es->map.x) * es->width / es->map.width;
727 sy = (y - es->map.y) * es->height / es->map.height;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500728 wl_surface_post_event(&es->base, &device->base,
Kristian Høgsberg5a75c902008-12-10 13:16:50 -0500729 WL_INPUT_MOTION, x, y, sx, sy);
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500730 }
731
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500732 device->x = x;
733 device->y = y;
Kristian Høgsberg29573bc2008-12-11 23:27:27 -0500734 device->pointer_surface->map.x = x - hotspot_x;
735 device->pointer_surface->map.y = y - hotspot_y;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500736
737 schedule_repaint(device->ec);
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500738}
739
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500740void
741notify_button(struct egl_input_device *device,
742 int32_t button, int32_t state)
Kristian Høgsbergeac149a2008-12-10 00:24:18 -0500743{
Kristian Høgsbergeac149a2008-12-10 00:24:18 -0500744 struct egl_surface *es;
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500745 int32_t sx, sy;
Kristian Høgsbergeac149a2008-12-10 00:24:18 -0500746
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500747 es = pick_surface(device);
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500748 if (es) {
749 wl_list_remove(&es->link);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500750 wl_list_insert(device->ec->surface_list.prev, &es->link);
Kristian Høgsberg5a75c902008-12-10 13:16:50 -0500751
Kristian Høgsberg29573bc2008-12-11 23:27:27 -0500752 if (state) {
Kristian Høgsberga7700c82008-12-12 13:48:30 -0500753 /* FIXME: We need callbacks when the surfaces
754 * we reference here go away. */
Kristian Høgsberg29573bc2008-12-11 23:27:27 -0500755 device->grab++;
756 device->grab_surface = es;
Kristian Høgsberga7700c82008-12-12 13:48:30 -0500757 device->focus_surface = es;
Kristian Høgsberg29573bc2008-12-11 23:27:27 -0500758 } else {
759 device->grab--;
760 }
761
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500762 sx = (device->x - es->map.x) * es->width / es->map.width;
763 sy = (device->y - es->map.y) * es->height / es->map.height;
764
Kristian Høgsberg5a75c902008-12-10 13:16:50 -0500765 /* FIXME: Swallow click on raise? */
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500766 wl_surface_post_event(&es->base, &device->base,
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500767 WL_INPUT_BUTTON, button, state,
768 device->x, device->y, sx, sy);
Kristian Høgsbergeac149a2008-12-10 00:24:18 -0500769
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500770 schedule_repaint(device->ec);
771 }
Kristian Høgsbergeac149a2008-12-10 00:24:18 -0500772}
773
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500774void
775notify_key(struct egl_input_device *device,
776 uint32_t key, uint32_t state)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500777{
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500778 struct egl_compositor *ec = device->ec;
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500779
Kristian Høgsberg9af92b32008-11-24 01:12:46 -0500780 if (key == KEY_ESC && state == 1) {
781 if (ec->overlay_target == ec->height)
782 ec->overlay_target -= 200;
783 else
784 ec->overlay_target += 200;
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500785 schedule_repaint(ec);
Kristian Høgsberg7fdff042008-12-10 13:25:00 -0500786 } else if (!wl_list_empty(&ec->surface_list)) {
Kristian Høgsberga7700c82008-12-12 13:48:30 -0500787 if (device->focus_surface != NULL)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500788 wl_surface_post_event(&device->focus_surface->base,
Kristian Høgsberga7700c82008-12-12 13:48:30 -0500789 &device->base,
790 WL_INPUT_KEY, key, state);
Kristian Høgsberg9af92b32008-11-24 01:12:46 -0500791 }
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500792}
793
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500794struct evdev_input_device *
795evdev_input_device_create(struct egl_input_device *device,
796 struct wl_display *display, const char *path);
797
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500798static void
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500799create_input_device(struct egl_compositor *ec, const char *glob)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500800{
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500801 struct egl_input_device *device;
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500802 struct dirent *de;
803 char path[PATH_MAX];
804 const char *by_path_dir = "/dev/input/by-path";
805 DIR *dir;
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500806
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500807 device = malloc(sizeof *device);
808 if (device == NULL)
809 return;
810
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500811 memset(device, 0, sizeof *device);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500812 device->base.interface = wl_input_device_get_interface();
813 wl_display_add_object(ec->wl_display, &device->base);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500814 device->x = 100;
815 device->y = 100;
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500816 device->pointer_surface = pointer_create(ec,
817 device->x, device->y, 64, 64);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500818 device->ec = ec;
819
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500820 dir = opendir(by_path_dir);
821 if (dir == NULL) {
822 fprintf(stderr, "couldn't read dir %s\n", by_path_dir);
823 return;
824 }
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500825
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500826 while (de = readdir(dir), de != NULL) {
827 if (fnmatch(glob, de->d_name, 0))
828 continue;
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500829
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500830 snprintf(path, sizeof path, "%s/%s", by_path_dir, de->d_name);
831 evdev_input_device_create(device, ec->wl_display, path);
832 }
833 closedir(dir);
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500834
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500835 wl_list_insert(ec->input_device_list.prev, &device->link);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500836}
837
838void
839egl_device_get_position(struct egl_input_device *device, int32_t *x, int32_t *y)
840{
841 *x = device->x;
842 *y = device->y;
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500843}
844
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -0500845static uint32_t
846create_frontbuffer(int fd, int *width, int *height, int *stride)
847{
848 drmModeConnector *connector;
849 drmModeRes *resources;
850 drmModeEncoder *encoder;
851 struct drm_mode_modeinfo *mode;
852 struct drm_i915_gem_create create;
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -0500853 struct drm_gem_flink flink;
854 unsigned int fb_id;
855 int i, ret;
856
857 resources = drmModeGetResources(fd);
858 if (!resources) {
859 fprintf(stderr, "drmModeGetResources failed\n");
860 return 0;
861 }
862
863 for (i = 0; i < resources->count_connectors; i++) {
864 connector = drmModeGetConnector(fd, resources->connectors[i]);
865 if (connector == NULL)
866 continue;
867
868 if (connector->connection == DRM_MODE_CONNECTED &&
869 connector->count_modes > 0)
870 break;
871
872 drmModeFreeConnector(connector);
873 }
874
875 if (i == resources->count_connectors) {
876 fprintf(stderr, "No currently active connector found.\n");
877 return -1;
878 }
879
880 mode = &connector->modes[0];
881
882 for (i = 0; i < resources->count_encoders; i++) {
883 encoder = drmModeGetEncoder(fd, resources->encoders[i]);
884
885 if (encoder == NULL)
886 continue;
887
888 if (encoder->encoder_id == connector->encoder_id)
889 break;
890
891 drmModeFreeEncoder(encoder);
892 }
893
894 /* Mode size at 32 bpp */
895 create.size = mode->hdisplay * mode->vdisplay * 4;
896 if (ioctl(fd, DRM_IOCTL_I915_GEM_CREATE, &create) != 0) {
897 fprintf(stderr, "gem create failed: %m\n");
898 return 0;
899 }
900
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -0500901 ret = drmModeAddFB(fd, mode->hdisplay, mode->vdisplay,
902 32, 32, mode->hdisplay * 4, create.handle, &fb_id);
903 if (ret) {
904 fprintf(stderr, "failed to add fb: %m\n");
905 return 0;
906 }
907
908 ret = drmModeSetCrtc(fd, encoder->crtc_id, fb_id, 0, 0,
909 &connector->connector_id, 1, mode);
910 if (ret) {
911 fprintf(stderr, "failed to set mode: %m\n");
912 return 0;
913 }
914
915 flink.handle = create.handle;
916 if (ioctl(fd, DRM_IOCTL_GEM_FLINK, &flink) != 0) {
917 fprintf(stderr, "gem flink failed: %m\n");
918 return 0;
919 }
920
921 *width = mode->hdisplay;
922 *height = mode->vdisplay;
923 *stride = mode->hdisplay * 4;
924
925 return flink.name;
926}
927
Kristian Høgsberg443853c2008-11-25 12:12:05 -0500928static int
929pick_config(struct egl_compositor *ec)
930{
931 EGLConfig configs[100];
932 EGLint value, count;
933 int i;
934
935 if (!eglGetConfigs(ec->display, configs, ARRAY_LENGTH(configs), &count)) {
936 fprintf(stderr, "failed to get configs\n");
937 return -1;
938 }
939
940 ec->config = EGL_NO_CONFIG;
941 for (i = 0; i < count; i++) {
942 eglGetConfigAttrib(ec->display,
943 configs[i],
944 EGL_DEPTH_SIZE,
945 &value);
946 if (value > 0) {
947 fprintf(stderr, "config %d has depth size %d\n", i, value);
948 continue;
949 }
950
951 eglGetConfigAttrib(ec->display,
952 configs[i],
953 EGL_STENCIL_SIZE,
954 &value);
955 if (value > 0) {
956 fprintf(stderr, "config %d has stencil size %d\n", i, value);
957 continue;
958 }
959
960 eglGetConfigAttrib(ec->display,
961 configs[i],
962 EGL_CONFIG_CAVEAT,
963 &value);
964 if (value != EGL_NONE) {
965 fprintf(stderr, "config %d has caveat %d\n", i, value);
966 continue;
967 }
968
969 ec->config = configs[i];
970 break;
971 }
972
973 if (ec->config == EGL_NO_CONFIG) {
974 fprintf(stderr, "found no config without depth or stencil buffers\n");
975 return -1;
976 }
977
978 return 0;
979}
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -0500980
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500981static const struct wl_interface visual_interface = {
982 "visual", 1,
983};
984
985static void
986add_visuals(struct egl_compositor *ec)
987{
988 ec->argb_visual.base.interface = &visual_interface;
989 ec->argb_visual.base.implementation = NULL;
990 wl_display_add_object(ec->wl_display, &ec->argb_visual.base);
991 wl_display_add_global(ec->wl_display, &ec->argb_visual.base);
992
993 ec->premultiplied_argb_visual.base.interface = &visual_interface;
994 ec->premultiplied_argb_visual.base.implementation = NULL;
995 wl_display_add_object(ec->wl_display,
996 &ec->premultiplied_argb_visual.base);
997 wl_display_add_global(ec->wl_display,
998 &ec->premultiplied_argb_visual.base);
999
1000 ec->rgb_visual.base.interface = &visual_interface;
1001 ec->rgb_visual.base.implementation = NULL;
1002 wl_display_add_object(ec->wl_display, &ec->rgb_visual.base);
1003 wl_display_add_global(ec->wl_display, &ec->rgb_visual.base);
1004}
1005
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001006static const char gem_device[] = "/dev/dri/card0";
1007
Kristian Høgsbergc492b482008-12-12 12:00:02 -05001008static const char *macbook_air_default_input_device[] = {
Kristian Høgsberg64949972008-12-12 14:48:46 -05001009 "pci-0000:00:1d.2-usb-0:2:1*event*",
1010 NULL
Kristian Høgsbergc492b482008-12-12 12:00:02 -05001011};
Kristian Høgsbergd6531262008-12-12 11:06:18 -05001012
Kristian Høgsbergc492b482008-12-12 12:00:02 -05001013static const char *option_background = "background.jpg";
1014static const char **option_input_devices = macbook_air_default_input_device;
1015
1016static const GOptionEntry option_entries[] = {
1017 { "background", 'b', 0, G_OPTION_ARG_STRING,
1018 &option_background, "Background image" },
1019 { "input-device", 'i', 0, G_OPTION_ARG_STRING_ARRAY,
1020 &option_input_devices, "Input device glob" },
Kristian Høgsbergd6531262008-12-12 11:06:18 -05001021 { NULL }
1022};
1023
Kristian Høgsberg122912c2008-12-05 11:13:50 -05001024static struct egl_compositor *
1025egl_compositor_create(struct wl_display *display)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001026{
Kristian Høgsberg443853c2008-11-25 12:12:05 -05001027 EGLint major, minor;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001028 struct egl_compositor *ec;
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -05001029 struct screenshooter *shooter;
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05001030 uint32_t fb_name;
Kristian Høgsbergc492b482008-12-12 12:00:02 -05001031 int i, stride;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001032 struct wl_event_loop *loop;
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05001033 const static EGLint attribs[] =
1034 { EGL_RENDER_BUFFER, EGL_BACK_BUFFER, EGL_NONE };
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001035
1036 ec = malloc(sizeof *ec);
1037 if (ec == NULL)
1038 return NULL;
1039
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001040 ec->wl_display = display;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001041
Kristian Høgsbergc508d932008-10-13 22:52:42 -04001042 ec->display = eglCreateDisplayNative(gem_device, "i965");
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001043 if (ec->display == NULL) {
1044 fprintf(stderr, "failed to create display\n");
1045 return NULL;
1046 }
1047
1048 if (!eglInitialize(ec->display, &major, &minor)) {
1049 fprintf(stderr, "failed to initialize display\n");
1050 return NULL;
1051 }
1052
Kristian Høgsberg443853c2008-11-25 12:12:05 -05001053 if (pick_config(ec))
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001054 return NULL;
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05001055
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05001056 fb_name = create_frontbuffer(eglGetDisplayFD(ec->display),
1057 &ec->width, &ec->height, &stride);
1058 ec->surface = eglCreateSurfaceForName(ec->display, ec->config,
1059 fb_name, ec->width, ec->height, stride, attribs);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001060 if (ec->surface == NULL) {
1061 fprintf(stderr, "failed to create surface\n");
1062 return NULL;
1063 }
1064
Kristian Høgsberg2d9cd1e2008-11-03 08:09:34 -05001065 ec->context = eglCreateContext(ec->display, ec->config, NULL, NULL);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001066 if (ec->context == NULL) {
1067 fprintf(stderr, "failed to create context\n");
1068 return NULL;
1069 }
1070
1071 if (!eglMakeCurrent(ec->display, ec->surface, ec->surface, ec->context)) {
1072 fprintf(stderr, "failed to make context current\n");
1073 return NULL;
1074 }
1075
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05001076 glViewport(0, 0, ec->width, ec->height);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001077 glMatrixMode(GL_PROJECTION);
1078 glLoadIdentity();
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05001079 glOrtho(0, ec->width, ec->height, 0, 0, 1000.0);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001080 glMatrixMode(GL_MODELVIEW);
Kristian Høgsberg5b7f8322008-12-18 12:08:19 -05001081 glClearColor(0, 0, 0.2, 1);
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001082
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001083 wl_display_set_compositor(display, &ec->base, &compositor_interface);
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -05001084 add_visuals(ec);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001085
Kristian Høgsbergc492b482008-12-12 12:00:02 -05001086 wl_list_init(&ec->input_device_list);
1087 for (i = 0; option_input_devices[i]; i++)
1088 create_input_device(ec, option_input_devices[i]);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001089
Kristian Høgsberg201a9042008-12-10 00:40:50 -05001090 wl_list_init(&ec->surface_list);
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -05001091 ec->background = background_create(ec, option_background,
Kristian Høgsbergd6531262008-12-12 11:06:18 -05001092 ec->width, ec->height);
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -05001093 ec->overlay = overlay_create(ec, 0, ec->height, ec->width, 200);
Kristian Høgsberg9f88b182008-12-08 13:52:08 -05001094 ec->overlay_y = ec->height;
Kristian Høgsberg9af92b32008-11-24 01:12:46 -05001095 ec->overlay_target = ec->height;
1096 ec->overlay_previous = ec->height;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -05001097
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001098 ec->gem_fd = open(gem_device, O_RDWR);
1099 if (ec->gem_fd < 0) {
1100 fprintf(stderr, "failed to open drm device\n");
1101 return NULL;
1102 }
1103
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -05001104 shooter = screenshooter_create(ec);
1105 wl_display_add_object(display, &shooter->base);
1106 wl_display_add_global(display, &shooter->base);
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05001107
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001108 loop = wl_display_get_event_loop(ec->wl_display);
Kristian Høgsberg4a298902008-11-28 18:35:25 -05001109 ec->timer_source = wl_event_loop_add_timer(loop, repaint, ec);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001110 ec->repaint_needed = 0;
1111 ec->repaint_on_timeout = 0;
1112
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001113 schedule_repaint(ec);
1114
Kristian Høgsberg122912c2008-12-05 11:13:50 -05001115 return ec;
1116}
1117
1118/* The plan here is to generate a random anonymous socket name and
1119 * advertise that through a service on the session dbus.
1120 */
1121static const char socket_name[] = "\0wayland";
1122
1123int main(int argc, char *argv[])
1124{
1125 struct wl_display *display;
1126 struct egl_compositor *ec;
Kristian Høgsbergd6531262008-12-12 11:06:18 -05001127 GError *error = NULL;
1128 GOptionContext *context;
1129
1130 context = g_option_context_new(NULL);
1131 g_option_context_add_main_entries(context, option_entries, "Wayland");
1132 if (!g_option_context_parse(context, &argc, &argv, &error)) {
1133 fprintf(stderr, "option parsing failed: %s\n", error->message);
1134 exit(EXIT_FAILURE);
1135 }
Kristian Høgsberg122912c2008-12-05 11:13:50 -05001136
1137 display = wl_display_create();
1138
1139 ec = egl_compositor_create(display);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05001140 if (ec == NULL) {
1141 fprintf(stderr, "failed to create compositor\n");
1142 exit(EXIT_FAILURE);
1143 }
1144
Kristian Høgsbergdc0f3552008-12-07 15:22:22 -05001145 if (wl_display_add_socket(display, socket_name, sizeof socket_name)) {
Kristian Høgsberg122912c2008-12-05 11:13:50 -05001146 fprintf(stderr, "failed to add socket: %m\n");
1147 exit(EXIT_FAILURE);
1148 }
1149
1150 wl_display_run(display);
1151
1152 return 0;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001153}