Kristian Høgsberg | ffd710e | 2008-12-02 15:15:01 -0500 | [diff] [blame] | 1 | /* |
| 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øgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 23 | #include <stdint.h> |
| 24 | #include <stdio.h> |
| 25 | #include <stdlib.h> |
| 26 | #include <string.h> |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 27 | #include <fcntl.h> |
| 28 | #include <unistd.h> |
| 29 | #include <math.h> |
| 30 | #include <time.h> |
| 31 | #include <cairo.h> |
Kristian Høgsberg | 1cbaa6a | 2008-11-07 15:54:48 -0500 | [diff] [blame] | 32 | #include <glib.h> |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 33 | #include <glib-object.h> |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 34 | #include <gdk-pixbuf/gdk-pixbuf.h> |
Kristian Høgsberg | 640609a | 2010-08-09 22:11:47 -0400 | [diff] [blame] | 35 | #include <xf86drm.h> |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 36 | |
| 37 | #define EGL_EGLEXT_PROTOTYPES 1 |
| 38 | #define GL_GLEXT_PROTOTYPES 1 |
| 39 | #include <GL/gl.h> |
| 40 | #include <EGL/egl.h> |
| 41 | #include <EGL/eglext.h> |
| 42 | #include <cairo-gl.h> |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 43 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 44 | #include <X11/extensions/XKBcommon.h> |
| 45 | |
Kristian Høgsberg | 5ee1a60 | 2008-12-11 23:18:45 -0500 | [diff] [blame] | 46 | #include <linux/input.h> |
Kristian Høgsberg | 3c38fa0 | 2009-02-23 22:30:29 -0500 | [diff] [blame] | 47 | #include "wayland-util.h" |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 48 | #include "wayland-client.h" |
Kristian Høgsberg | 1cbaa6a | 2008-11-07 15:54:48 -0500 | [diff] [blame] | 49 | #include "wayland-glib.h" |
Kristian Høgsberg | b91cd10 | 2010-08-16 16:17:42 -0400 | [diff] [blame] | 50 | #include "cairo-util.h" |
Kristian Høgsberg | 2f2cfae | 2008-11-08 22:46:30 -0500 | [diff] [blame] | 51 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 52 | #include "window.h" |
Kristian Høgsberg | 8a9cda8 | 2008-11-03 15:31:30 -0500 | [diff] [blame] | 53 | |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 54 | struct display { |
Kristian Høgsberg | 4097923 | 2008-11-25 22:40:39 -0500 | [diff] [blame] | 55 | struct wl_display *display; |
Kristian Høgsberg | d2412e2 | 2008-12-15 20:35:24 -0500 | [diff] [blame] | 56 | struct wl_compositor *compositor; |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 57 | struct wl_shell *shell; |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 58 | struct wl_drm *drm; |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 59 | struct wl_output *output; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 60 | struct wl_drag *drag; |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 61 | struct rectangle screen_allocation; |
Kristian Høgsberg | 640609a | 2010-08-09 22:11:47 -0400 | [diff] [blame] | 62 | int authenticated; |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 63 | EGLDisplay dpy; |
| 64 | EGLContext ctx; |
Janusz Lewandowski | d923e9d | 2010-01-31 03:01:26 +0100 | [diff] [blame] | 65 | cairo_device_t *device; |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 66 | int fd; |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 67 | GMainLoop *loop; |
| 68 | GSource *source; |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 69 | struct wl_list window_list; |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 70 | struct wl_list input_list; |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 71 | char *device_name; |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 72 | cairo_surface_t *active_frame, *inactive_frame, *shadow; |
Kristian Høgsberg | 3e6e7e6 | 2010-07-02 15:12:02 -0400 | [diff] [blame] | 73 | struct xkb_desc *xkb; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 74 | cairo_surface_t **pointer_surfaces; |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 75 | }; |
| 76 | |
| 77 | struct window { |
| 78 | struct display *display; |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 79 | struct wl_surface *surface; |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 80 | const char *title; |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 81 | struct rectangle allocation, saved_allocation, pending_allocation; |
| 82 | int resize_edges; |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 83 | int redraw_scheduled; |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 84 | int minimum_width, minimum_height; |
Kristian Høgsberg | 4097923 | 2008-11-25 22:40:39 -0500 | [diff] [blame] | 85 | int margin; |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 86 | int fullscreen; |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 87 | int decoration; |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 88 | struct input *grab_device; |
| 89 | struct input *keyboard_device; |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 90 | uint32_t name; |
Kristian Høgsberg | 78231c8 | 2008-11-08 15:06:01 -0500 | [diff] [blame] | 91 | |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 92 | EGLImageKHR *image; |
Kristian Høgsberg | 6a1b201 | 2009-12-16 14:43:37 -0500 | [diff] [blame] | 93 | cairo_surface_t *cairo_surface, *pending_surface; |
Kristian Høgsberg | 8a9cda8 | 2008-11-03 15:31:30 -0500 | [diff] [blame] | 94 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 95 | window_resize_handler_t resize_handler; |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 96 | window_redraw_handler_t redraw_handler; |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 97 | window_key_handler_t key_handler; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 98 | window_button_handler_t button_handler; |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 99 | window_keyboard_focus_handler_t keyboard_focus_handler; |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 100 | window_acknowledge_handler_t acknowledge_handler; |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 101 | window_frame_handler_t frame_handler; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 102 | window_motion_handler_t motion_handler; |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 103 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 104 | void *user_data; |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 105 | struct wl_list link; |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 106 | }; |
| 107 | |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 108 | struct input { |
| 109 | struct display *display; |
| 110 | struct wl_input_device *input_device; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 111 | struct wl_drag *drag; |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 112 | struct window *pointer_focus; |
| 113 | struct window *keyboard_focus; |
| 114 | uint32_t modifiers; |
| 115 | int32_t x, y, sx, sy; |
| 116 | struct wl_list link; |
| 117 | }; |
| 118 | |
Kristian Høgsberg | e4feb56 | 2008-11-08 18:53:37 -0500 | [diff] [blame] | 119 | static void |
| 120 | rounded_rect(cairo_t *cr, int x0, int y0, int x1, int y1, int radius) |
| 121 | { |
| 122 | cairo_move_to(cr, x0, y0 + radius); |
| 123 | cairo_arc(cr, x0 + radius, y0 + radius, radius, M_PI, 3 * M_PI / 2); |
| 124 | cairo_line_to(cr, x1 - radius, y0); |
| 125 | cairo_arc(cr, x1 - radius, y0 + radius, radius, 3 * M_PI / 2, 2 * M_PI); |
| 126 | cairo_line_to(cr, x1, y1 - radius); |
| 127 | cairo_arc(cr, x1 - radius, y1 - radius, radius, 0, M_PI / 2); |
| 128 | cairo_line_to(cr, x0 + radius, y1); |
| 129 | cairo_arc(cr, x0 + radius, y1 - radius, radius, M_PI / 2, M_PI); |
| 130 | cairo_close_path(cr); |
| 131 | } |
| 132 | |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 133 | static int |
| 134 | texture_from_png(const char *filename, int width, int height) |
| 135 | { |
| 136 | GdkPixbuf *pixbuf; |
| 137 | GError *error = NULL; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 138 | int stride, i; |
| 139 | unsigned char *pixels, *p, *end; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 140 | |
| 141 | pixbuf = gdk_pixbuf_new_from_file_at_scale(filename, |
| 142 | width, height, |
| 143 | FALSE, &error); |
| 144 | if (error != NULL) |
| 145 | return -1; |
| 146 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 147 | if (!gdk_pixbuf_get_has_alpha(pixbuf) || |
| 148 | gdk_pixbuf_get_n_channels(pixbuf) != 4) { |
| 149 | gdk_pixbuf_unref(pixbuf); |
| 150 | return -1; |
| 151 | } |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 152 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 153 | |
| 154 | stride = gdk_pixbuf_get_rowstride(pixbuf); |
| 155 | pixels = gdk_pixbuf_get_pixels(pixbuf); |
| 156 | |
| 157 | for (i = 0; i < height; i++) { |
| 158 | p = pixels + i * stride; |
| 159 | end = p + width * 4; |
| 160 | while (p < end) { |
| 161 | unsigned int t; |
| 162 | |
| 163 | #define MULT(d,c,a,t) \ |
| 164 | do { t = c * a + 0x7f; d = ((t >> 8) + t) >> 8; } while (0) |
| 165 | |
| 166 | MULT(p[0], p[0], p[3], t); |
| 167 | MULT(p[1], p[1], p[3], t); |
| 168 | MULT(p[2], p[2], p[3], t); |
| 169 | p += 4; |
| 170 | |
| 171 | } |
| 172 | } |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 173 | |
| 174 | glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 175 | width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels); |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 176 | |
| 177 | gdk_pixbuf_unref(pixbuf); |
| 178 | |
| 179 | return 0; |
| 180 | } |
| 181 | |
| 182 | static const struct { |
| 183 | const char *filename; |
| 184 | int hotspot_x, hotspot_y; |
| 185 | } pointer_images[] = { |
| 186 | { DATADIR "/wayland/bottom_left_corner.png", 6, 30 }, |
| 187 | { DATADIR "/wayland/bottom_right_corner.png", 28, 28 }, |
| 188 | { DATADIR "/wayland/bottom_side.png", 16, 20 }, |
| 189 | { DATADIR "/wayland/grabbing.png", 20, 17 }, |
| 190 | { DATADIR "/wayland/left_ptr.png", 10, 5 }, |
| 191 | { DATADIR "/wayland/left_side.png", 10, 20 }, |
| 192 | { DATADIR "/wayland/right_side.png", 30, 19 }, |
| 193 | { DATADIR "/wayland/top_left_corner.png", 8, 8 }, |
| 194 | { DATADIR "/wayland/top_right_corner.png", 26, 8 }, |
| 195 | { DATADIR "/wayland/top_side.png", 18, 8 }, |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 196 | { DATADIR "/wayland/xterm.png", 15, 15 }, |
| 197 | { DATADIR "/wayland/hand1.png", 18, 11 } |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 198 | }; |
| 199 | |
| 200 | static void |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 201 | create_pointer_surfaces(struct display *display) |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 202 | { |
| 203 | int i, count; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 204 | const int width = 32, height = 32; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 205 | struct rectangle rect; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 206 | |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 207 | count = ARRAY_LENGTH(pointer_images); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 208 | display->pointer_surfaces = |
| 209 | malloc(count * sizeof *display->pointer_surfaces); |
| 210 | rect.width = width; |
| 211 | rect.height = height; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 212 | for (i = 0; i < count; i++) { |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 213 | display->pointer_surfaces[i] = |
| 214 | display_create_surface(display, &rect); |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 215 | texture_from_png(pointer_images[i].filename, width, height); |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | } |
| 219 | |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 220 | static const cairo_user_data_key_t surface_data_key; |
| 221 | struct surface_data { |
| 222 | EGLImageKHR image; |
| 223 | GLuint texture; |
| 224 | EGLDisplay dpy; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 225 | struct wl_buffer *buffer; |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 226 | }; |
| 227 | |
| 228 | static void |
| 229 | surface_data_destroy(void *p) |
| 230 | { |
| 231 | struct surface_data *data = p; |
| 232 | |
| 233 | glDeleteTextures(1, &data->texture); |
| 234 | eglDestroyImageKHR(data->dpy, data->image); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 235 | if (data->buffer) |
| 236 | wl_buffer_destroy(data->buffer); |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 237 | } |
| 238 | |
| 239 | cairo_surface_t * |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 240 | display_create_surface(struct display *display, |
| 241 | struct rectangle *rectangle) |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 242 | { |
| 243 | struct surface_data *data; |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 244 | EGLDisplay dpy = display->dpy; |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 245 | cairo_surface_t *surface; |
| 246 | |
| 247 | EGLint image_attribs[] = { |
| 248 | EGL_WIDTH, 0, |
| 249 | EGL_HEIGHT, 0, |
| 250 | EGL_IMAGE_FORMAT_MESA, EGL_IMAGE_FORMAT_ARGB8888_MESA, |
| 251 | EGL_IMAGE_USE_MESA, EGL_IMAGE_USE_SCANOUT_MESA, |
| 252 | EGL_NONE |
| 253 | }; |
| 254 | |
| 255 | data = malloc(sizeof *data); |
| 256 | image_attribs[1] = rectangle->width; |
| 257 | image_attribs[3] = rectangle->height; |
| 258 | data->image = eglCreateDRMImageMESA(dpy, image_attribs); |
| 259 | glGenTextures(1, &data->texture); |
| 260 | data->dpy = dpy; |
| 261 | glBindTexture(GL_TEXTURE_2D, data->texture); |
| 262 | glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, data->image); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 263 | data->buffer = NULL; |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 264 | |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 265 | surface = cairo_gl_surface_create_for_texture(display->device, |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 266 | CAIRO_CONTENT_COLOR_ALPHA, |
| 267 | data->texture, |
| 268 | rectangle->width, |
| 269 | rectangle->height); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 270 | |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 271 | cairo_surface_set_user_data (surface, &surface_data_key, |
| 272 | data, surface_data_destroy); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 273 | |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 274 | return surface; |
| 275 | } |
| 276 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 277 | struct wl_buffer * |
| 278 | display_get_buffer_for_surface(struct display *display, |
| 279 | cairo_surface_t *surface) |
| 280 | { |
| 281 | struct surface_data *data; |
| 282 | struct wl_visual *visual; |
| 283 | struct wl_buffer *buffer; |
| 284 | EGLint name, stride; |
| 285 | int width, height; |
| 286 | |
| 287 | data = cairo_surface_get_user_data (surface, &surface_data_key); |
| 288 | if (data->buffer) |
| 289 | return data->buffer; |
| 290 | |
| 291 | width = cairo_gl_surface_get_width (surface); |
| 292 | height = cairo_gl_surface_get_height (surface); |
| 293 | |
| 294 | eglExportDRMImageMESA(display->dpy, data->image, &name, NULL, &stride); |
| 295 | |
| 296 | visual = wl_display_get_premultiplied_argb_visual(display->display); |
| 297 | buffer = wl_drm_create_buffer(display->drm, |
| 298 | name, width, height, stride, visual); |
| 299 | data->buffer = buffer; |
| 300 | |
| 301 | return buffer; |
| 302 | } |
| 303 | |
| 304 | cairo_surface_t * |
| 305 | display_get_pointer_surface(struct display *display, int pointer, |
| 306 | int *width, int *height, |
| 307 | int *hotspot_x, int *hotspot_y) |
| 308 | { |
| 309 | cairo_surface_t *surface; |
| 310 | |
| 311 | surface = display->pointer_surfaces[pointer]; |
| 312 | *width = cairo_gl_surface_get_width(surface); |
| 313 | *height = cairo_gl_surface_get_height(surface); |
| 314 | *hotspot_x = pointer_images[pointer].hotspot_x; |
| 315 | *hotspot_y = pointer_images[pointer].hotspot_y; |
| 316 | |
| 317 | return cairo_surface_reference(surface); |
| 318 | } |
| 319 | |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 320 | static void |
Kristian Høgsberg | 6a1b201 | 2009-12-16 14:43:37 -0500 | [diff] [blame] | 321 | window_attach_surface(struct window *window) |
| 322 | { |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 323 | struct display *display = window->display; |
| 324 | struct wl_buffer *buffer; |
Kristian Høgsberg | 6a1b201 | 2009-12-16 14:43:37 -0500 | [diff] [blame] | 325 | |
Kristian Høgsberg | 2aac302 | 2009-12-21 10:04:53 -0500 | [diff] [blame] | 326 | if (window->pending_surface != NULL) |
| 327 | return; |
| 328 | |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 329 | window->pending_surface = window->cairo_surface; |
| 330 | window->cairo_surface = NULL; |
Kristian Høgsberg | 2aac302 | 2009-12-21 10:04:53 -0500 | [diff] [blame] | 331 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 332 | buffer = display_get_buffer_for_surface(display, |
| 333 | window->pending_surface); |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 334 | wl_surface_attach(window->surface, buffer); |
Kristian Høgsberg | 6a1b201 | 2009-12-16 14:43:37 -0500 | [diff] [blame] | 335 | |
| 336 | wl_surface_map(window->surface, |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 337 | window->allocation.x, |
| 338 | window->allocation.y, |
| 339 | window->allocation.width, |
| 340 | window->allocation.height); |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 341 | |
| 342 | wl_compositor_commit(window->display->compositor, 0); |
Kristian Høgsberg | 6a1b201 | 2009-12-16 14:43:37 -0500 | [diff] [blame] | 343 | } |
| 344 | |
Kristian Høgsberg | a341fa0 | 2010-01-24 18:10:15 -0500 | [diff] [blame] | 345 | void |
| 346 | window_commit(struct window *window, uint32_t key) |
| 347 | { |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 348 | if (window->cairo_surface) { |
Kristian Høgsberg | a341fa0 | 2010-01-24 18:10:15 -0500 | [diff] [blame] | 349 | window_attach_surface(window); |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 350 | } else { |
| 351 | wl_compositor_commit(window->display->compositor, key); |
Kristian Høgsberg | a341fa0 | 2010-01-24 18:10:15 -0500 | [diff] [blame] | 352 | } |
Kristian Høgsberg | a341fa0 | 2010-01-24 18:10:15 -0500 | [diff] [blame] | 353 | } |
| 354 | |
Kristian Høgsberg | 6a1b201 | 2009-12-16 14:43:37 -0500 | [diff] [blame] | 355 | static void |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 356 | window_draw_decorations(struct window *window) |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 357 | { |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 358 | cairo_t *cr; |
Kristian Høgsberg | ca1d1f6 | 2008-11-03 06:59:52 -0500 | [diff] [blame] | 359 | cairo_text_extents_t extents; |
Kristian Høgsberg | 2d6b7c1 | 2010-06-25 16:51:57 -0400 | [diff] [blame] | 360 | cairo_pattern_t *outline, *bright, *dim; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 361 | cairo_surface_t *frame; |
| 362 | int width, height, shadow_dx = 3, shadow_dy = 3; |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 363 | |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 364 | window->cairo_surface = |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 365 | display_create_surface(window->display, &window->allocation); |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 366 | width = window->allocation.width; |
| 367 | height = window->allocation.height; |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 368 | |
Kristian Høgsberg | e4feb56 | 2008-11-08 18:53:37 -0500 | [diff] [blame] | 369 | outline = cairo_pattern_create_rgb(0.1, 0.1, 0.1); |
Kristian Høgsberg | e9d550b | 2008-11-19 00:49:39 -0500 | [diff] [blame] | 370 | bright = cairo_pattern_create_rgb(0.8, 0.8, 0.8); |
Kristian Høgsberg | e4feb56 | 2008-11-08 18:53:37 -0500 | [diff] [blame] | 371 | dim = cairo_pattern_create_rgb(0.4, 0.4, 0.4); |
| 372 | |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 373 | cr = cairo_create(window->cairo_surface); |
Kristian Høgsberg | 2f2cfae | 2008-11-08 22:46:30 -0500 | [diff] [blame] | 374 | |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 375 | cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 376 | cairo_set_source_rgba(cr, 0, 0, 0, 0); |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 377 | cairo_paint(cr); |
| 378 | |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 379 | cairo_set_source_rgba(cr, 0, 0, 0, 0.6); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 380 | tile_mask(cr, window->display->shadow, |
| 381 | shadow_dx, shadow_dy, width, height, |
| 382 | window->margin + 10 - shadow_dx, |
| 383 | window->margin + 10 - shadow_dy); |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 384 | |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 385 | if (window->keyboard_device) |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 386 | frame = window->display->active_frame; |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 387 | else |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 388 | frame = window->display->inactive_frame; |
| 389 | |
| 390 | tile_source(cr, frame, 0, 0, width, height, |
| 391 | window->margin + 10, window->margin + 50); |
Kristian Høgsberg | e4feb56 | 2008-11-08 18:53:37 -0500 | [diff] [blame] | 392 | |
Kristian Høgsberg | e4feb56 | 2008-11-08 18:53:37 -0500 | [diff] [blame] | 393 | cairo_set_operator(cr, CAIRO_OPERATOR_OVER); |
| 394 | cairo_set_font_size(cr, 14); |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 395 | cairo_text_extents(cr, window->title, &extents); |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 396 | cairo_move_to(cr, (width - extents.width) / 2, 32 - extents.y_bearing); |
Kristian Høgsberg | e4feb56 | 2008-11-08 18:53:37 -0500 | [diff] [blame] | 397 | cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); |
| 398 | cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); |
| 399 | cairo_set_line_width (cr, 4); |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 400 | if (window->keyboard_device) |
| 401 | cairo_set_source_rgb(cr, 0, 0, 0); |
| 402 | else |
Kristian Høgsberg | 7d7b5db | 2009-09-21 13:43:46 -0400 | [diff] [blame] | 403 | cairo_set_source_rgb(cr, 0.8, 0.8, 0.8); |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 404 | cairo_show_text(cr, window->title); |
| 405 | |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 406 | cairo_destroy(cr); |
Kristian Høgsberg | 10ddbd2 | 2010-08-16 21:08:52 -0400 | [diff] [blame] | 407 | |
| 408 | cairo_device_flush (window->display->device); |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 409 | } |
| 410 | |
| 411 | static void |
| 412 | window_draw_fullscreen(struct window *window) |
| 413 | { |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 414 | window->cairo_surface = |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 415 | display_create_surface(window->display, &window->allocation); |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 416 | } |
| 417 | |
| 418 | void |
| 419 | window_draw(struct window *window) |
| 420 | { |
Kristian Høgsberg | 2aac302 | 2009-12-21 10:04:53 -0500 | [diff] [blame] | 421 | if (window->cairo_surface != NULL) |
| 422 | cairo_surface_destroy(window->cairo_surface); |
| 423 | |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 424 | if (window->fullscreen || !window->decoration) |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 425 | window_draw_fullscreen(window); |
| 426 | else |
| 427 | window_draw_decorations(window); |
Kristian Høgsberg | 44f36e3 | 2008-11-26 12:57:31 -0500 | [diff] [blame] | 428 | } |
| 429 | |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 430 | cairo_surface_t * |
| 431 | window_get_surface(struct window *window) |
| 432 | { |
| 433 | return window->cairo_surface; |
| 434 | } |
| 435 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 436 | enum window_location { |
| 437 | WINDOW_INTERIOR = 0, |
Kristian Høgsberg | bf6ceda | 2010-06-14 20:25:06 -0400 | [diff] [blame] | 438 | WINDOW_RESIZING_TOP = 1, |
| 439 | WINDOW_RESIZING_BOTTOM = 2, |
| 440 | WINDOW_RESIZING_LEFT = 4, |
| 441 | WINDOW_RESIZING_TOP_LEFT = 5, |
| 442 | WINDOW_RESIZING_BOTTOM_LEFT = 6, |
| 443 | WINDOW_RESIZING_RIGHT = 8, |
| 444 | WINDOW_RESIZING_TOP_RIGHT = 9, |
| 445 | WINDOW_RESIZING_BOTTOM_RIGHT = 10, |
| 446 | WINDOW_RESIZING_MASK = 15, |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 447 | WINDOW_EXTERIOR = 16, |
| 448 | WINDOW_TITLEBAR = 17, |
| 449 | WINDOW_CLIENT_AREA = 18, |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 450 | }; |
| 451 | |
| 452 | static int |
| 453 | get_pointer_location(struct window *window, int32_t x, int32_t y) |
| 454 | { |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 455 | int vlocation, hlocation, location; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 456 | const int grip_size = 8; |
| 457 | |
| 458 | if (x < window->margin) |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 459 | hlocation = WINDOW_EXTERIOR; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 460 | else if (window->margin <= x && x < window->margin + grip_size) |
| 461 | hlocation = WINDOW_RESIZING_LEFT; |
| 462 | else if (x < window->allocation.width - window->margin - grip_size) |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 463 | hlocation = WINDOW_INTERIOR; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 464 | else if (x < window->allocation.width - window->margin) |
| 465 | hlocation = WINDOW_RESIZING_RIGHT; |
| 466 | else |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 467 | hlocation = WINDOW_EXTERIOR; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 468 | |
| 469 | if (y < window->margin) |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 470 | vlocation = WINDOW_EXTERIOR; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 471 | else if (window->margin <= y && y < window->margin + grip_size) |
| 472 | vlocation = WINDOW_RESIZING_TOP; |
| 473 | else if (y < window->allocation.height - window->margin - grip_size) |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 474 | vlocation = WINDOW_INTERIOR; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 475 | else if (y < window->allocation.height - window->margin) |
| 476 | vlocation = WINDOW_RESIZING_BOTTOM; |
| 477 | else |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 478 | vlocation = WINDOW_EXTERIOR; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 479 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 480 | location = vlocation | hlocation; |
| 481 | if (location & WINDOW_EXTERIOR) |
| 482 | location = WINDOW_EXTERIOR; |
| 483 | if (location == WINDOW_INTERIOR && y < window->margin + 50) |
| 484 | location = WINDOW_TITLEBAR; |
| 485 | else if (location == WINDOW_INTERIOR) |
| 486 | location = WINDOW_CLIENT_AREA; |
| 487 | |
| 488 | return location; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 489 | } |
| 490 | |
| 491 | static void |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 492 | set_pointer_image(struct input *input, int pointer) |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 493 | { |
| 494 | struct display *display = input->display; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 495 | struct wl_buffer *buffer; |
| 496 | cairo_surface_t *surface; |
| 497 | int location; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 498 | |
| 499 | location = get_pointer_location(input->pointer_focus, |
| 500 | input->sx, input->sy); |
| 501 | switch (location) { |
| 502 | case WINDOW_RESIZING_TOP: |
| 503 | pointer = POINTER_TOP; |
| 504 | break; |
| 505 | case WINDOW_RESIZING_BOTTOM: |
| 506 | pointer = POINTER_BOTTOM; |
| 507 | break; |
| 508 | case WINDOW_RESIZING_LEFT: |
| 509 | pointer = POINTER_LEFT; |
| 510 | break; |
| 511 | case WINDOW_RESIZING_RIGHT: |
| 512 | pointer = POINTER_RIGHT; |
| 513 | break; |
| 514 | case WINDOW_RESIZING_TOP_LEFT: |
| 515 | pointer = POINTER_TOP_LEFT; |
| 516 | break; |
| 517 | case WINDOW_RESIZING_TOP_RIGHT: |
| 518 | pointer = POINTER_TOP_RIGHT; |
| 519 | break; |
| 520 | case WINDOW_RESIZING_BOTTOM_LEFT: |
| 521 | pointer = POINTER_BOTTOM_LEFT; |
| 522 | break; |
| 523 | case WINDOW_RESIZING_BOTTOM_RIGHT: |
| 524 | pointer = POINTER_BOTTOM_RIGHT; |
| 525 | break; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 526 | case WINDOW_EXTERIOR: |
| 527 | case WINDOW_TITLEBAR: |
| 528 | wl_input_device_attach(input->input_device, NULL, 0, 0); |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 529 | return; |
| 530 | default: |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 531 | break; |
| 532 | } |
| 533 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 534 | surface = display->pointer_surfaces[pointer]; |
| 535 | buffer = display_get_buffer_for_surface(display, surface); |
| 536 | wl_input_device_attach(input->input_device, buffer, |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 537 | pointer_images[pointer].hotspot_x, |
| 538 | pointer_images[pointer].hotspot_y); |
| 539 | } |
| 540 | |
Kristian Høgsberg | e4feb56 | 2008-11-08 18:53:37 -0500 | [diff] [blame] | 541 | static void |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 542 | window_handle_motion(void *data, struct wl_input_device *input_device, |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 543 | uint32_t time, |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 544 | int32_t x, int32_t y, int32_t sx, int32_t sy) |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 545 | { |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 546 | struct input *input = data; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 547 | struct window *window = input->pointer_focus; |
| 548 | int location, pointer = POINTER_LEFT_PTR; |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 549 | |
| 550 | input->x = x; |
| 551 | input->y = y; |
| 552 | input->sx = sx; |
| 553 | input->sy = sy; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 554 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 555 | location = get_pointer_location(window, input->sx, input->sy); |
| 556 | |
| 557 | if (window->motion_handler) |
| 558 | pointer = (*window->motion_handler)(window, input, time, |
| 559 | x, y, sx, sy, |
| 560 | window->user_data); |
| 561 | |
| 562 | set_pointer_image(input, pointer); |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 563 | } |
| 564 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 565 | static void window_handle_button(void *data, |
| 566 | struct wl_input_device *input_device, |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 567 | uint32_t time, uint32_t button, uint32_t state) |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 568 | { |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 569 | struct input *input = data; |
| 570 | struct window *window = input->pointer_focus; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 571 | int location; |
Kristian Høgsberg | bf6ceda | 2010-06-14 20:25:06 -0400 | [diff] [blame] | 572 | |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 573 | location = get_pointer_location(window, input->sx, input->sy); |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 574 | |
| 575 | if (button == BTN_LEFT && state == 1) { |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 576 | switch (location) { |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 577 | case WINDOW_TITLEBAR: |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 578 | wl_shell_move(window->display->shell, |
| 579 | window->surface, input_device, time); |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 580 | break; |
Kristian Høgsberg | bf6ceda | 2010-06-14 20:25:06 -0400 | [diff] [blame] | 581 | case WINDOW_RESIZING_TOP: |
| 582 | case WINDOW_RESIZING_BOTTOM: |
| 583 | case WINDOW_RESIZING_LEFT: |
| 584 | case WINDOW_RESIZING_RIGHT: |
| 585 | case WINDOW_RESIZING_TOP_LEFT: |
| 586 | case WINDOW_RESIZING_TOP_RIGHT: |
| 587 | case WINDOW_RESIZING_BOTTOM_LEFT: |
| 588 | case WINDOW_RESIZING_BOTTOM_RIGHT: |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 589 | wl_shell_resize(window->display->shell, |
| 590 | window->surface, input_device, time, |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 591 | location); |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 592 | break; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 593 | case WINDOW_CLIENT_AREA: |
| 594 | if (window->button_handler) |
| 595 | (*window->button_handler)(window, |
| 596 | input, time, |
| 597 | button, state, |
| 598 | window->user_data); |
| 599 | break; |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 600 | } |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 601 | } else { |
| 602 | if (window->button_handler) |
| 603 | (*window->button_handler)(window, |
| 604 | input, time, |
| 605 | button, state, |
| 606 | window->user_data); |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 607 | } |
| 608 | } |
| 609 | |
Kristian Høgsberg | 99f090d | 2009-02-23 22:37:14 -0500 | [diff] [blame] | 610 | static void |
| 611 | window_handle_key(void *data, struct wl_input_device *input_device, |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 612 | uint32_t time, uint32_t key, uint32_t state) |
Kristian Høgsberg | 99f090d | 2009-02-23 22:37:14 -0500 | [diff] [blame] | 613 | { |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 614 | struct input *input = data; |
| 615 | struct window *window = input->keyboard_focus; |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 616 | struct display *d = window->display; |
| 617 | uint32_t code, sym, level; |
Kristian Høgsberg | 99f090d | 2009-02-23 22:37:14 -0500 | [diff] [blame] | 618 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 619 | code = key + d->xkb->min_key_code; |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 620 | if (window->keyboard_device != input) |
Kristian Høgsberg | 99f090d | 2009-02-23 22:37:14 -0500 | [diff] [blame] | 621 | return; |
| 622 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 623 | level = 0; |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 624 | if (input->modifiers & WINDOW_MODIFIER_SHIFT && |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 625 | XkbKeyGroupWidth(d->xkb, code, 0) > 1) |
| 626 | level = 1; |
Kristian Høgsberg | 99f090d | 2009-02-23 22:37:14 -0500 | [diff] [blame] | 627 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 628 | sym = XkbKeySymEntry(d->xkb, code, level, 0); |
| 629 | |
| 630 | if (state) |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 631 | input->modifiers |= d->xkb->map->modmap[code]; |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 632 | else |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 633 | input->modifiers &= ~d->xkb->map->modmap[code]; |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 634 | |
| 635 | if (window->key_handler) |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 636 | (*window->key_handler)(window, key, sym, state, |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 637 | input->modifiers, window->user_data); |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 638 | } |
| 639 | |
Kristian Høgsberg | db6c2f3 | 2009-02-22 21:51:24 -0500 | [diff] [blame] | 640 | static void |
| 641 | window_handle_pointer_focus(void *data, |
| 642 | struct wl_input_device *input_device, |
Kristian Høgsberg | 6d70202 | 2010-08-06 15:12:22 -0400 | [diff] [blame] | 643 | uint32_t time, struct wl_surface *surface, |
| 644 | int32_t x, int32_t y, int32_t sx, int32_t sy) |
Kristian Høgsberg | db6c2f3 | 2009-02-22 21:51:24 -0500 | [diff] [blame] | 645 | { |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 646 | struct input *input = data; |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 647 | struct window *window; |
| 648 | int pointer; |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 649 | |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 650 | if (surface) { |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 651 | input->pointer_focus = wl_surface_get_user_data(surface); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 652 | window = input->pointer_focus; |
| 653 | |
| 654 | pointer = POINTER_LEFT_PTR; |
| 655 | if (window->motion_handler) |
| 656 | pointer = (*window->motion_handler)(window, |
| 657 | input, time, |
| 658 | x, y, sx, sy, |
| 659 | window->user_data); |
| 660 | |
| 661 | set_pointer_image(input, pointer); |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 662 | } else { |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 663 | input->pointer_focus = NULL; |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 664 | } |
Kristian Høgsberg | db6c2f3 | 2009-02-22 21:51:24 -0500 | [diff] [blame] | 665 | } |
| 666 | |
| 667 | static void |
| 668 | window_handle_keyboard_focus(void *data, |
| 669 | struct wl_input_device *input_device, |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 670 | uint32_t time, |
Kristian Høgsberg | 3c38fa0 | 2009-02-23 22:30:29 -0500 | [diff] [blame] | 671 | struct wl_surface *surface, |
| 672 | struct wl_array *keys) |
Kristian Høgsberg | db6c2f3 | 2009-02-22 21:51:24 -0500 | [diff] [blame] | 673 | { |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 674 | struct input *input = data; |
| 675 | struct window *window = input->keyboard_focus; |
| 676 | struct display *d = input->display; |
Kristian Høgsberg | 99f090d | 2009-02-23 22:37:14 -0500 | [diff] [blame] | 677 | uint32_t *k, *end; |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 678 | |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 679 | window = input->keyboard_focus; |
| 680 | if (window) { |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 681 | window->keyboard_device = NULL; |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 682 | if (window->keyboard_focus_handler) |
| 683 | (*window->keyboard_focus_handler)(window, NULL, |
| 684 | window->user_data); |
Kristian Høgsberg | 99f090d | 2009-02-23 22:37:14 -0500 | [diff] [blame] | 685 | } |
| 686 | |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 687 | if (surface) |
| 688 | input->keyboard_focus = wl_surface_get_user_data(surface); |
| 689 | else |
| 690 | input->keyboard_focus = NULL; |
| 691 | |
| 692 | end = keys->data + keys->size; |
| 693 | for (k = keys->data; k < end; k++) |
| 694 | input->modifiers |= d->xkb->map->modmap[*k]; |
| 695 | |
| 696 | window = input->keyboard_focus; |
| 697 | if (window) { |
| 698 | window->keyboard_device = input; |
| 699 | if (window->keyboard_focus_handler) |
| 700 | (*window->keyboard_focus_handler)(window, |
| 701 | window->keyboard_device, |
| 702 | window->user_data); |
| 703 | } |
Kristian Høgsberg | db6c2f3 | 2009-02-22 21:51:24 -0500 | [diff] [blame] | 704 | } |
| 705 | |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 706 | static const struct wl_input_device_listener input_device_listener = { |
| 707 | window_handle_motion, |
| 708 | window_handle_button, |
| 709 | window_handle_key, |
Kristian Høgsberg | db6c2f3 | 2009-02-22 21:51:24 -0500 | [diff] [blame] | 710 | window_handle_pointer_focus, |
| 711 | window_handle_keyboard_focus, |
Kristian Høgsberg | 94448c0 | 2008-12-30 11:03:33 -0500 | [diff] [blame] | 712 | }; |
| 713 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 714 | void |
| 715 | input_get_position(struct input *input, int32_t *x, int32_t *y) |
| 716 | { |
| 717 | *x = input->sx; |
| 718 | *y = input->sy; |
| 719 | } |
| 720 | |
| 721 | void |
| 722 | window_start_drag(struct window *window, struct input *input, uint32_t time, |
| 723 | struct wl_buffer *buffer, int32_t x, int32_t y) |
| 724 | { |
| 725 | cairo_device_flush (window->display->device); |
| 726 | |
| 727 | wl_drag_prepare(input->drag, window->surface, time, buffer, x, y); |
| 728 | wl_drag_offer(input->drag, "text/plain"); |
| 729 | wl_drag_activate(input->drag); |
| 730 | } |
| 731 | |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 732 | static void |
| 733 | handle_configure(void *data, struct wl_shell *shell, |
| 734 | uint32_t time, uint32_t edges, |
| 735 | struct wl_surface *surface, |
| 736 | int32_t x, int32_t y, int32_t width, int32_t height) |
| 737 | { |
| 738 | struct window *window = wl_surface_get_user_data(surface); |
| 739 | |
| 740 | window->resize_edges = edges; |
| 741 | window->pending_allocation.x = x; |
| 742 | window->pending_allocation.y = y; |
| 743 | window->pending_allocation.width = width; |
| 744 | window->pending_allocation.height = height; |
| 745 | |
| 746 | if (!(edges & 15)) |
| 747 | return; |
| 748 | |
| 749 | if (window->resize_handler) |
| 750 | (*window->resize_handler)(window, |
| 751 | window->user_data); |
| 752 | else if (window->redraw_handler) |
| 753 | window_schedule_redraw(window); |
| 754 | } |
| 755 | |
| 756 | static const struct wl_shell_listener shell_listener = { |
| 757 | handle_configure, |
| 758 | }; |
| 759 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 760 | void |
| 761 | window_get_child_rectangle(struct window *window, |
| 762 | struct rectangle *rectangle) |
Kristian Høgsberg | 8a9cda8 | 2008-11-03 15:31:30 -0500 | [diff] [blame] | 763 | { |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 764 | if (window->fullscreen && !window->decoration) { |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 765 | *rectangle = window->allocation; |
| 766 | } else { |
| 767 | rectangle->x = window->margin + 10; |
| 768 | rectangle->y = window->margin + 50; |
| 769 | rectangle->width = window->allocation.width - 20 - window->margin * 2; |
| 770 | rectangle->height = window->allocation.height - 60 - window->margin * 2; |
| 771 | } |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 772 | } |
| 773 | |
| 774 | void |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 775 | window_set_child_size(struct window *window, |
| 776 | struct rectangle *rectangle) |
| 777 | { |
Kristian Høgsberg | bf6ceda | 2010-06-14 20:25:06 -0400 | [diff] [blame] | 778 | int32_t width, height; |
| 779 | |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 780 | if (!window->fullscreen) { |
Kristian Høgsberg | bf6ceda | 2010-06-14 20:25:06 -0400 | [diff] [blame] | 781 | width = rectangle->width + 20 + window->margin * 2; |
| 782 | height = rectangle->height + 60 + window->margin * 2; |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 783 | |
| 784 | if (window->resize_edges & WINDOW_RESIZING_LEFT) |
| 785 | window->allocation.x += |
| 786 | window->allocation.width - width; |
| 787 | if (window->resize_edges & WINDOW_RESIZING_TOP) |
| 788 | window->allocation.y += |
| 789 | window->allocation.height - height; |
| 790 | |
Kristian Høgsberg | bf6ceda | 2010-06-14 20:25:06 -0400 | [diff] [blame] | 791 | window->allocation.width = width; |
| 792 | window->allocation.height = height; |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 793 | } |
Kristian Høgsberg | 2210676 | 2008-12-08 13:50:07 -0500 | [diff] [blame] | 794 | } |
| 795 | |
| 796 | void |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 797 | window_copy_image(struct window *window, |
| 798 | struct rectangle *rectangle, EGLImageKHR image) |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 799 | { |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 800 | /* set image as read buffer, copy pixels or something... */ |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 801 | } |
| 802 | |
| 803 | void |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 804 | window_copy_surface(struct window *window, |
| 805 | struct rectangle *rectangle, |
| 806 | cairo_surface_t *surface) |
| 807 | { |
Kristian Høgsberg | 2aac302 | 2009-12-21 10:04:53 -0500 | [diff] [blame] | 808 | cairo_t *cr; |
| 809 | |
| 810 | cr = cairo_create (window->cairo_surface); |
| 811 | |
| 812 | cairo_set_source_surface (cr, |
| 813 | surface, |
| 814 | rectangle->x, rectangle->y); |
| 815 | |
| 816 | cairo_paint (cr); |
| 817 | cairo_destroy (cr); |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 818 | } |
| 819 | |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 820 | static gboolean |
| 821 | idle_redraw(void *data) |
| 822 | { |
| 823 | struct window *window = data; |
| 824 | |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 825 | if (window->resize_edges) |
| 826 | window->allocation = window->pending_allocation; |
| 827 | |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 828 | window->redraw_handler(window, window->user_data); |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 829 | |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 830 | window->redraw_scheduled = 0; |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 831 | window->resize_edges = 0; |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 832 | |
| 833 | return FALSE; |
| 834 | } |
| 835 | |
| 836 | void |
| 837 | window_schedule_redraw(struct window *window) |
| 838 | { |
| 839 | if (!window->redraw_scheduled) { |
| 840 | g_idle_add(idle_redraw, window); |
| 841 | window->redraw_scheduled = 1; |
| 842 | } |
| 843 | } |
| 844 | |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 845 | void |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 846 | window_set_fullscreen(struct window *window, int fullscreen) |
| 847 | { |
| 848 | window->fullscreen = fullscreen; |
| 849 | if (window->fullscreen) { |
| 850 | window->saved_allocation = window->allocation; |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 851 | window->allocation = window->display->screen_allocation; |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 852 | } else { |
| 853 | window->allocation = window->saved_allocation; |
| 854 | } |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 855 | } |
| 856 | |
| 857 | void |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 858 | window_set_decoration(struct window *window, int decoration) |
| 859 | { |
| 860 | window->decoration = decoration; |
| 861 | } |
| 862 | |
| 863 | void |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 864 | window_set_user_data(struct window *window, void *data) |
| 865 | { |
| 866 | window->user_data = data; |
| 867 | } |
| 868 | |
| 869 | void |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 870 | window_set_resize_handler(struct window *window, |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 871 | window_resize_handler_t handler) |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 872 | { |
| 873 | window->resize_handler = handler; |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 874 | } |
| 875 | |
| 876 | void |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 877 | window_set_redraw_handler(struct window *window, |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 878 | window_redraw_handler_t handler) |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 879 | { |
| 880 | window->redraw_handler = handler; |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 881 | } |
| 882 | |
| 883 | void |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 884 | window_set_key_handler(struct window *window, |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 885 | window_key_handler_t handler) |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 886 | { |
| 887 | window->key_handler = handler; |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 888 | } |
| 889 | |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 890 | void |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 891 | window_set_button_handler(struct window *window, |
| 892 | window_button_handler_t handler) |
| 893 | { |
| 894 | window->button_handler = handler; |
| 895 | } |
| 896 | |
| 897 | void |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 898 | window_set_acknowledge_handler(struct window *window, |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 899 | window_acknowledge_handler_t handler) |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 900 | { |
| 901 | window->acknowledge_handler = handler; |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 902 | } |
| 903 | |
| 904 | void |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 905 | window_set_frame_handler(struct window *window, |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 906 | window_frame_handler_t handler) |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 907 | { |
| 908 | window->frame_handler = handler; |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 909 | } |
| 910 | |
| 911 | void |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 912 | window_set_motion_handler(struct window *window, |
| 913 | window_motion_handler_t handler) |
| 914 | { |
| 915 | window->motion_handler = handler; |
| 916 | } |
| 917 | |
| 918 | void |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 919 | window_set_keyboard_focus_handler(struct window *window, |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 920 | window_keyboard_focus_handler_t handler) |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 921 | { |
| 922 | window->keyboard_focus_handler = handler; |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 923 | } |
| 924 | |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 925 | void |
| 926 | window_move(struct window *window, int32_t x, int32_t y) |
| 927 | { |
| 928 | window->allocation.x = x; |
| 929 | window->allocation.y = y; |
| 930 | |
| 931 | wl_surface_map(window->surface, |
| 932 | window->allocation.x - window->margin, |
| 933 | window->allocation.y - window->margin, |
| 934 | window->allocation.width, |
| 935 | window->allocation.height); |
| 936 | } |
| 937 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 938 | struct window * |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 939 | window_create(struct display *display, const char *title, |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 940 | int32_t x, int32_t y, int32_t width, int32_t height) |
| 941 | { |
Kristian Høgsberg | 1cbaa6a | 2008-11-07 15:54:48 -0500 | [diff] [blame] | 942 | struct window *window; |
| 943 | |
| 944 | window = malloc(sizeof *window); |
| 945 | if (window == NULL) |
| 946 | return NULL; |
| 947 | |
Kristian Høgsberg | 78231c8 | 2008-11-08 15:06:01 -0500 | [diff] [blame] | 948 | memset(window, 0, sizeof *window); |
Kristian Høgsberg | 4097923 | 2008-11-25 22:40:39 -0500 | [diff] [blame] | 949 | window->display = display; |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 950 | window->title = strdup(title); |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 951 | window->surface = wl_compositor_create_surface(display->compositor); |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 952 | window->allocation.x = x; |
| 953 | window->allocation.y = y; |
| 954 | window->allocation.width = width; |
| 955 | window->allocation.height = height; |
| 956 | window->saved_allocation = window->allocation; |
Kristian Høgsberg | 4097923 | 2008-11-25 22:40:39 -0500 | [diff] [blame] | 957 | window->margin = 16; |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 958 | window->decoration = 1; |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 959 | |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 960 | wl_surface_set_user_data(window->surface, window); |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 961 | wl_list_insert(display->window_list.prev, &window->link); |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 962 | |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 963 | return window; |
| 964 | } |
| 965 | |
| 966 | static void |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 967 | drm_handle_device(void *data, struct wl_drm *drm, const char *device) |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 968 | { |
| 969 | struct display *d = data; |
| 970 | |
| 971 | d->device_name = strdup(device); |
| 972 | } |
| 973 | |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 974 | static void drm_handle_authenticated(void *data, struct wl_drm *drm) |
| 975 | { |
Kristian Høgsberg | 640609a | 2010-08-09 22:11:47 -0400 | [diff] [blame] | 976 | struct display *d = data; |
| 977 | |
| 978 | d->authenticated = 1; |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 979 | } |
| 980 | |
| 981 | static const struct wl_drm_listener drm_listener = { |
| 982 | drm_handle_device, |
| 983 | drm_handle_authenticated |
| 984 | }; |
| 985 | |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 986 | static void |
| 987 | display_handle_acknowledge(void *data, |
| 988 | struct wl_compositor *compositor, |
| 989 | uint32_t key, uint32_t frame) |
| 990 | { |
| 991 | struct display *d = data; |
| 992 | struct window *window; |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 993 | |
| 994 | /* The acknowledge event means that the server processed our |
| 995 | * last commit request and we can now safely free the old |
| 996 | * window buffer if we resized and render the next frame into |
| 997 | * our back buffer.. */ |
| 998 | wl_list_for_each(window, &d->window_list, link) { |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 999 | cairo_surface_destroy(window->pending_surface); |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 1000 | window->pending_surface = NULL; |
Kristian Høgsberg | 0953162 | 2010-06-14 23:22:15 -0400 | [diff] [blame] | 1001 | if (window->cairo_surface) |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 1002 | window_attach_surface(window); |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 1003 | if (window->acknowledge_handler) |
| 1004 | (*window->acknowledge_handler)(window, key, frame, window->user_data); |
| 1005 | } |
| 1006 | } |
| 1007 | |
| 1008 | static void |
| 1009 | display_handle_frame(void *data, |
| 1010 | struct wl_compositor *compositor, |
| 1011 | uint32_t frame, uint32_t timestamp) |
| 1012 | { |
| 1013 | struct display *d = data; |
| 1014 | struct window *window; |
| 1015 | |
| 1016 | wl_list_for_each(window, &d->window_list, link) { |
| 1017 | if (window->frame_handler) |
| 1018 | (*window->frame_handler)(window, frame, |
| 1019 | timestamp, window->user_data); |
| 1020 | } |
| 1021 | } |
| 1022 | |
| 1023 | static const struct wl_compositor_listener compositor_listener = { |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 1024 | display_handle_acknowledge, |
| 1025 | display_handle_frame, |
| 1026 | }; |
| 1027 | |
| 1028 | static void |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1029 | display_handle_geometry(void *data, |
| 1030 | struct wl_output *output, |
| 1031 | int32_t width, int32_t height) |
| 1032 | { |
| 1033 | struct display *display = data; |
| 1034 | |
| 1035 | display->screen_allocation.x = 0; |
| 1036 | display->screen_allocation.y = 0; |
| 1037 | display->screen_allocation.width = width; |
| 1038 | display->screen_allocation.height = height; |
| 1039 | } |
| 1040 | |
| 1041 | static const struct wl_output_listener output_listener = { |
| 1042 | display_handle_geometry, |
| 1043 | }; |
| 1044 | |
| 1045 | static void |
Kristian Høgsberg | 4fe1a3e | 2010-08-10 14:02:48 -0400 | [diff] [blame] | 1046 | display_add_input(struct display *d, uint32_t id) |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 1047 | { |
| 1048 | struct input *input; |
| 1049 | |
| 1050 | input = malloc(sizeof *input); |
| 1051 | if (input == NULL) |
| 1052 | return; |
| 1053 | |
| 1054 | memset(input, 0, sizeof *input); |
| 1055 | input->display = d; |
Kristian Høgsberg | 4fe1a3e | 2010-08-10 14:02:48 -0400 | [diff] [blame] | 1056 | input->input_device = wl_input_device_create(d->display, id); |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 1057 | input->pointer_focus = NULL; |
| 1058 | input->keyboard_focus = NULL; |
| 1059 | wl_list_insert(d->input_list.prev, &input->link); |
| 1060 | |
| 1061 | wl_input_device_add_listener(input->input_device, |
| 1062 | &input_device_listener, input); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 1063 | wl_input_device_set_user_data(input->input_device, input); |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 1064 | } |
| 1065 | |
| 1066 | static void |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 1067 | drag_handle_device(void *data, |
| 1068 | struct wl_drag *drag, struct wl_input_device *device) |
| 1069 | { |
| 1070 | struct input *input; |
| 1071 | fprintf(stderr, "device for drag %p: %p\n", drag, device); |
| 1072 | |
| 1073 | input = wl_input_device_get_user_data(device); |
| 1074 | input->drag = drag; |
| 1075 | |
| 1076 | } |
| 1077 | |
| 1078 | static void |
| 1079 | drag_pointer_focus(void *data, |
| 1080 | struct wl_drag *drag, |
| 1081 | uint32_t time, struct wl_surface *surface, |
| 1082 | int32_t x, int32_t y, int32_t surface_x, int32_t surface_y) |
| 1083 | { |
| 1084 | fprintf(stderr, "drag pointer focus %p\n", surface); |
| 1085 | } |
| 1086 | |
| 1087 | static void |
| 1088 | drag_offer(void *data, |
| 1089 | struct wl_drag *drag, const char *type) |
| 1090 | { |
| 1091 | fprintf(stderr, "drag offer %s\n", type); |
| 1092 | } |
| 1093 | |
| 1094 | static void |
| 1095 | drag_motion(void *data, |
| 1096 | struct wl_drag *drag, |
| 1097 | uint32_t time, |
| 1098 | int32_t x, int32_t y, int32_t surface_x, int32_t surface_y) |
| 1099 | { |
| 1100 | fprintf(stderr, "drag motion %d,%d\n", surface_x, surface_y); |
| 1101 | } |
| 1102 | |
| 1103 | static void |
| 1104 | drag_target(void *data, |
| 1105 | struct wl_drag *drag, const char *mime_type) |
| 1106 | { |
| 1107 | } |
| 1108 | |
| 1109 | static void |
| 1110 | drag_finish(void *data, struct wl_drag *drag) |
| 1111 | { |
| 1112 | fprintf(stderr, "drag finish\n"); |
| 1113 | } |
| 1114 | |
| 1115 | static void |
| 1116 | drag_data(void *data, |
| 1117 | struct wl_drag *drag, struct wl_array *contents) |
| 1118 | { |
| 1119 | } |
| 1120 | |
| 1121 | static const struct wl_drag_listener drag_listener = { |
| 1122 | drag_handle_device, |
| 1123 | drag_pointer_focus, |
| 1124 | drag_offer, |
| 1125 | drag_motion, |
| 1126 | drag_target, |
| 1127 | drag_finish, |
| 1128 | drag_data |
| 1129 | }; |
| 1130 | |
| 1131 | static void |
Kristian Høgsberg | 4fe1a3e | 2010-08-10 14:02:48 -0400 | [diff] [blame] | 1132 | display_handle_global(struct wl_display *display, uint32_t id, |
| 1133 | const char *interface, uint32_t version, void *data) |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1134 | { |
| 1135 | struct display *d = data; |
| 1136 | |
Kristian Høgsberg | 4fe1a3e | 2010-08-10 14:02:48 -0400 | [diff] [blame] | 1137 | if (strcmp(interface, "compositor") == 0) { |
| 1138 | d->compositor = wl_compositor_create(display, id); |
| 1139 | wl_compositor_add_listener(d->compositor, |
| 1140 | &compositor_listener, d); |
| 1141 | } else if (strcmp(interface, "output") == 0) { |
| 1142 | d->output = wl_output_create(display, id); |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1143 | wl_output_add_listener(d->output, &output_listener, d); |
Kristian Høgsberg | 4fe1a3e | 2010-08-10 14:02:48 -0400 | [diff] [blame] | 1144 | } else if (strcmp(interface, "input_device") == 0) { |
| 1145 | display_add_input(d, id); |
| 1146 | } else if (strcmp(interface, "shell") == 0) { |
| 1147 | d->shell = wl_shell_create(display, id); |
Kristian Høgsberg | 83fc061 | 2010-08-04 22:44:55 -0400 | [diff] [blame] | 1148 | wl_shell_add_listener(d->shell, &shell_listener, d); |
Kristian Høgsberg | 4fe1a3e | 2010-08-10 14:02:48 -0400 | [diff] [blame] | 1149 | } else if (strcmp(interface, "drm") == 0) { |
| 1150 | d->drm = wl_drm_create(display, id); |
Kristian Høgsberg | 5fcd0aa | 2010-08-09 14:43:33 -0400 | [diff] [blame] | 1151 | wl_drm_add_listener(d->drm, &drm_listener, d); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 1152 | } else if (strcmp(interface, "drag") == 0) { |
| 1153 | d->drag = wl_drag_create(display, id); |
| 1154 | wl_drag_add_listener(d->drag, &drag_listener, d); |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1155 | } |
| 1156 | } |
| 1157 | |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1158 | static const char socket_name[] = "\0wayland"; |
| 1159 | |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 1160 | static void |
| 1161 | display_render_frame(struct display *d) |
| 1162 | { |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 1163 | int radius = 8; |
| 1164 | cairo_t *cr; |
| 1165 | |
| 1166 | d->shadow = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 128, 128); |
| 1167 | cr = cairo_create(d->shadow); |
| 1168 | cairo_set_operator(cr, CAIRO_OPERATOR_OVER); |
| 1169 | cairo_set_source_rgba(cr, 0, 0, 0, 1); |
| 1170 | rounded_rect(cr, 16, 16, 112, 112, radius); |
| 1171 | cairo_fill(cr); |
| 1172 | cairo_destroy(cr); |
| 1173 | blur_surface(d->shadow, 64); |
| 1174 | |
| 1175 | d->active_frame = |
| 1176 | cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 128, 128); |
| 1177 | cr = cairo_create(d->active_frame); |
| 1178 | cairo_set_operator(cr, CAIRO_OPERATOR_OVER); |
| 1179 | cairo_set_source_rgba(cr, 0.8, 0.8, 0.4, 1); |
| 1180 | rounded_rect(cr, 16, 16, 112, 112, radius); |
| 1181 | cairo_fill(cr); |
| 1182 | cairo_destroy(cr); |
| 1183 | |
| 1184 | d->inactive_frame = |
| 1185 | cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 128, 128); |
| 1186 | cr = cairo_create(d->inactive_frame); |
| 1187 | cairo_set_operator(cr, CAIRO_OPERATOR_OVER); |
| 1188 | cairo_set_source_rgba(cr, 0.6, 0.6, 0.6, 1); |
| 1189 | rounded_rect(cr, 16, 16, 112, 112, radius); |
| 1190 | cairo_fill(cr); |
| 1191 | cairo_destroy(cr); |
| 1192 | } |
| 1193 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1194 | static void |
| 1195 | init_xkb(struct display *d) |
| 1196 | { |
Kristian Høgsberg | 3e6e7e6 | 2010-07-02 15:12:02 -0400 | [diff] [blame] | 1197 | struct xkb_rule_names names; |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1198 | |
Kristian Høgsberg | 3e6e7e6 | 2010-07-02 15:12:02 -0400 | [diff] [blame] | 1199 | names.rules = "evdev"; |
| 1200 | names.model = "pc105"; |
| 1201 | names.layout = "us"; |
| 1202 | names.variant = ""; |
| 1203 | names.options = ""; |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1204 | |
Kristian Høgsberg | 3e6e7e6 | 2010-07-02 15:12:02 -0400 | [diff] [blame] | 1205 | d->xkb = xkb_compile_keymap_from_rules(&names); |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1206 | if (!d->xkb) { |
| 1207 | fprintf(stderr, "Failed to compile keymap\n"); |
| 1208 | exit(1); |
| 1209 | } |
| 1210 | } |
| 1211 | |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1212 | struct display * |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1213 | display_create(int *argc, char **argv[], const GOptionEntry *option_entries) |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1214 | { |
| 1215 | struct display *d; |
Kristian Høgsberg | 379b678 | 2010-07-28 22:52:28 -0400 | [diff] [blame] | 1216 | EGLint major, minor; |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1217 | int fd; |
| 1218 | GOptionContext *context; |
| 1219 | GError *error; |
Kristian Høgsberg | 640609a | 2010-08-09 22:11:47 -0400 | [diff] [blame] | 1220 | drm_magic_t magic; |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 1221 | |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 1222 | g_type_init(); |
| 1223 | |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1224 | context = g_option_context_new(NULL); |
| 1225 | if (option_entries) { |
| 1226 | g_option_context_add_main_entries(context, option_entries, "Wayland View"); |
| 1227 | if (!g_option_context_parse(context, argc, argv, &error)) { |
| 1228 | fprintf(stderr, "option parsing failed: %s\n", error->message); |
| 1229 | exit(EXIT_FAILURE); |
| 1230 | } |
| 1231 | } |
| 1232 | |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1233 | d = malloc(sizeof *d); |
| 1234 | if (d == NULL) |
| 1235 | return NULL; |
| 1236 | |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 1237 | d->display = wl_display_create(socket_name, sizeof socket_name); |
| 1238 | if (d->display == NULL) { |
| 1239 | fprintf(stderr, "failed to create display: %m\n"); |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1240 | return NULL; |
| 1241 | } |
| 1242 | |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 1243 | wl_list_init(&d->input_list); |
| 1244 | |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 1245 | /* Set up listener so we'll catch all events. */ |
| 1246 | wl_display_add_global_listener(d->display, |
| 1247 | display_handle_global, d); |
| 1248 | |
| 1249 | /* Process connection events. */ |
| 1250 | wl_display_iterate(d->display, WL_DISPLAY_READABLE); |
| 1251 | |
| 1252 | fd = open(d->device_name, O_RDWR); |
| 1253 | if (fd < 0) { |
| 1254 | fprintf(stderr, "drm open failed: %m\n"); |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1255 | return NULL; |
| 1256 | } |
| 1257 | |
Kristian Høgsberg | 640609a | 2010-08-09 22:11:47 -0400 | [diff] [blame] | 1258 | if (drmGetMagic(fd, &magic)) { |
| 1259 | fprintf(stderr, "DRI2: failed to get drm magic"); |
| 1260 | return NULL; |
| 1261 | } |
| 1262 | |
| 1263 | /* Wait for authenticated event */ |
| 1264 | wl_drm_authenticate(d->drm, magic); |
| 1265 | wl_display_iterate(d->display, WL_DISPLAY_WRITABLE); |
| 1266 | while (!d->authenticated) |
| 1267 | wl_display_iterate(d->display, WL_DISPLAY_READABLE); |
| 1268 | |
Kristian Høgsberg | f252d6a | 2010-07-08 20:15:10 -0400 | [diff] [blame] | 1269 | d->dpy = eglGetDRMDisplayMESA(fd); |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 1270 | if (!eglInitialize(d->dpy, &major, &minor)) { |
| 1271 | fprintf(stderr, "failed to initialize display\n"); |
| 1272 | return NULL; |
| 1273 | } |
| 1274 | |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 1275 | eglBindAPI(EGL_OPENGL_API); |
| 1276 | |
Kristian Høgsberg | 379b678 | 2010-07-28 22:52:28 -0400 | [diff] [blame] | 1277 | d->ctx = eglCreateContext(d->dpy, NULL, EGL_NO_CONTEXT, NULL); |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 1278 | if (d->ctx == NULL) { |
| 1279 | fprintf(stderr, "failed to create context\n"); |
| 1280 | return NULL; |
| 1281 | } |
| 1282 | |
| 1283 | if (!eglMakeCurrent(d->dpy, NULL, NULL, d->ctx)) { |
| 1284 | fprintf(stderr, "faile to make context current\n"); |
| 1285 | return NULL; |
| 1286 | } |
| 1287 | |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 1288 | d->device = cairo_egl_device_create(d->dpy, d->ctx); |
Kristian Høgsberg | 2644910 | 2009-05-28 20:23:31 -0400 | [diff] [blame] | 1289 | if (d->device == NULL) { |
| 1290 | fprintf(stderr, "failed to get cairo drm device\n"); |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 1291 | return NULL; |
| 1292 | } |
Kristian Høgsberg | 8a9cda8 | 2008-11-03 15:31:30 -0500 | [diff] [blame] | 1293 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame^] | 1294 | create_pointer_surfaces(d); |
Kristian Høgsberg | da275dd | 2010-08-16 17:47:07 -0400 | [diff] [blame] | 1295 | |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 1296 | display_render_frame(d); |
| 1297 | |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1298 | d->loop = g_main_loop_new(NULL, FALSE); |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 1299 | d->source = wl_glib_source_new(d->display); |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1300 | g_source_attach(d->source, NULL); |
| 1301 | |
Kristian Høgsberg | 478d926 | 2010-06-08 20:34:11 -0400 | [diff] [blame] | 1302 | wl_list_init(&d->window_list); |
| 1303 | |
Kristian Høgsberg | 94adf6c | 2010-06-25 16:50:05 -0400 | [diff] [blame] | 1304 | init_xkb(d); |
| 1305 | |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 1306 | return d; |
| 1307 | } |
| 1308 | |
| 1309 | struct wl_compositor * |
| 1310 | display_get_compositor(struct display *display) |
| 1311 | { |
| 1312 | return display->compositor; |
Kristian Høgsberg | 61017b1 | 2008-11-02 18:51:48 -0500 | [diff] [blame] | 1313 | } |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 1314 | |
| 1315 | EGLDisplay |
| 1316 | display_get_egl_display(struct display *d) |
| 1317 | { |
| 1318 | return d->dpy; |
| 1319 | } |
| 1320 | |
| 1321 | void |
| 1322 | display_run(struct display *d) |
| 1323 | { |
| 1324 | g_main_loop_run(d->loop); |
| 1325 | } |