blob: e73e5887b11f64bd3dc5860231b2de156c081f4a [file] [log] [blame]
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001/*
2 * Copyright © 2011 Intel Corporation
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 */
22
23#define _GNU_SOURCE
24
25#include <stdlib.h>
26#include <stdio.h>
27#include <string.h>
28#include <sys/socket.h>
29#include <sys/un.h>
30#include <fcntl.h>
31#include <errno.h>
32#include <unistd.h>
33#include <signal.h>
Tiago Vignatti90fada42012-07-16 12:02:08 -040034#include <X11/Xcursor/Xcursor.h>
Kristian Høgsberg380deee2012-05-21 17:12:41 -040035
36#include "xwayland.h"
37
38#include "../../shared/cairo-util.h"
39#include "../compositor.h"
Martin Minarik6d118362012-06-07 18:01:59 +020040#include "../log.h"
Kristian Høgsberg380deee2012-05-21 17:12:41 -040041#include "xserver-server-protocol.h"
42#include "hash.h"
43
44struct motif_wm_hints {
45 uint32_t flags;
46 uint32_t functions;
47 uint32_t decorations;
48 int32_t input_mode;
49 uint32_t status;
50};
51
52#define MWM_HINTS_FUNCTIONS (1L << 0)
53#define MWM_HINTS_DECORATIONS (1L << 1)
54#define MWM_HINTS_INPUT_MODE (1L << 2)
55#define MWM_HINTS_STATUS (1L << 3)
56
57#define MWM_FUNC_ALL (1L << 0)
58#define MWM_FUNC_RESIZE (1L << 1)
59#define MWM_FUNC_MOVE (1L << 2)
60#define MWM_FUNC_MINIMIZE (1L << 3)
61#define MWM_FUNC_MAXIMIZE (1L << 4)
62#define MWM_FUNC_CLOSE (1L << 5)
63
64#define MWM_DECOR_ALL (1L << 0)
65#define MWM_DECOR_BORDER (1L << 1)
66#define MWM_DECOR_RESIZEH (1L << 2)
67#define MWM_DECOR_TITLE (1L << 3)
68#define MWM_DECOR_MENU (1L << 4)
69#define MWM_DECOR_MINIMIZE (1L << 5)
70#define MWM_DECOR_MAXIMIZE (1L << 6)
71
72#define MWM_INPUT_MODELESS 0
73#define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1
74#define MWM_INPUT_SYSTEM_MODAL 2
75#define MWM_INPUT_FULL_APPLICATION_MODAL 3
76#define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL
77
78#define MWM_TEAROFF_WINDOW (1L<<0)
79
80#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT 0
81#define _NET_WM_MOVERESIZE_SIZE_TOP 1
82#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT 2
83#define _NET_WM_MOVERESIZE_SIZE_RIGHT 3
84#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT 4
85#define _NET_WM_MOVERESIZE_SIZE_BOTTOM 5
86#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT 6
87#define _NET_WM_MOVERESIZE_SIZE_LEFT 7
88#define _NET_WM_MOVERESIZE_MOVE 8 /* movement only */
89#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD 9 /* size via keyboard */
90#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD 10 /* move via keyboard */
91#define _NET_WM_MOVERESIZE_CANCEL 11 /* cancel operation */
92
93
94
95struct weston_wm_window {
96 struct weston_wm *wm;
97 xcb_window_t id;
98 xcb_window_t frame_id;
99 cairo_surface_t *cairo_surface;
100 struct weston_surface *surface;
101 struct shell_surface *shsurf;
102 struct wl_listener surface_destroy_listener;
103 struct wl_event_source *repaint_source;
Kristian Høgsberga61ca062012-05-22 16:05:52 -0400104 struct wl_event_source *configure_source;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400105 int properties_dirty;
106 char *class;
107 char *name;
108 struct weston_wm_window *transient_for;
109 uint32_t protocols;
110 xcb_atom_t type;
111 int width, height;
112 int x, y;
113 int decorate;
Tiago Vignatti771241e2012-06-04 20:01:45 +0300114 int override_redirect;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400115};
116
117static struct weston_wm_window *
118get_wm_window(struct weston_surface *surface);
119
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400120static void
121weston_wm_window_schedule_repaint(struct weston_wm_window *window);
122
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400123const char *
124get_atom_name(xcb_connection_t *c, xcb_atom_t atom)
125{
126 xcb_get_atom_name_cookie_t cookie;
127 xcb_get_atom_name_reply_t *reply;
128 xcb_generic_error_t *e;
129 static char buffer[64];
130
131 if (atom == XCB_ATOM_NONE)
132 return "None";
133
134 cookie = xcb_get_atom_name (c, atom);
135 reply = xcb_get_atom_name_reply (c, cookie, &e);
136 snprintf(buffer, sizeof buffer, "%.*s",
137 xcb_get_atom_name_name_length (reply),
138 xcb_get_atom_name_name (reply));
139 free(reply);
140
141 return buffer;
142}
143
Tiago Vignatti90fada42012-07-16 12:02:08 -0400144static xcb_cursor_t
145xcb_cursor_image_load_cursor(struct weston_wm *wm, const XcursorImage *img)
146{
147 xcb_connection_t *c = wm->conn;
148 xcb_screen_iterator_t s = xcb_setup_roots_iterator(xcb_get_setup(c));
149 xcb_screen_t *screen = s.data;
150 xcb_gcontext_t gc;
151 xcb_pixmap_t pix;
152 xcb_render_picture_t pic;
153 xcb_cursor_t cursor;
154 int stride = img->width * 4;
155
156 pix = xcb_generate_id(c);
157 xcb_create_pixmap(c, 32, pix, screen->root, img->width, img->height);
158
159 pic = xcb_generate_id(c);
160 xcb_render_create_picture(c, pic, pix, wm->format_rgba.id, 0, 0);
161
162 gc = xcb_generate_id(c);
163 xcb_create_gc(c, gc, pix, 0, 0);
164
165 xcb_put_image(c, XCB_IMAGE_FORMAT_Z_PIXMAP, pix, gc,
166 img->width, img->height, 0, 0, 0, 32,
167 stride * img->height, (uint8_t *) img->pixels);
168 xcb_free_gc(c, gc);
169
170 cursor = xcb_generate_id(c);
171 xcb_render_create_cursor(c, cursor, pic, img->xhot, img->yhot);
172
173 xcb_render_free_picture(c, pic);
174 xcb_free_pixmap(c, pix);
175
176 return cursor;
177}
178
179static xcb_cursor_t
180xcb_cursor_images_load_cursor(struct weston_wm *wm, const XcursorImages *images)
181{
182 /* TODO: treat animated cursors as well */
183 if (images->nimage != 1)
184 return -1;
185
186 return xcb_cursor_image_load_cursor(wm, images->images[0]);
187}
188
189static xcb_cursor_t
190xcb_cursor_library_load_cursor(struct weston_wm *wm, const char *file)
191{
192 xcb_cursor_t cursor;
193 XcursorImages *images;
194 char *v = NULL;
195 int size = 0;
196
197 if (!file)
198 return 0;
199
200 v = getenv ("XCURSOR_SIZE");
201 if (v)
202 size = atoi(v);
203
204 if (!size)
205 size = 32;
206
207 images = XcursorLibraryLoadImages (file, NULL, size);
208 cursor = xcb_cursor_images_load_cursor (wm, images);
209 XcursorImagesDestroy (images);
210
211 return cursor;
212}
213
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400214void
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400215dump_property(struct weston_wm *wm,
216 xcb_atom_t property, xcb_get_property_reply_t *reply)
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400217{
218 int32_t *incr_value;
219 const char *text_value, *name;
220 xcb_atom_t *atom_value;
221 int width, len;
222 uint32_t i;
223
Martin Minarik6d118362012-06-07 18:01:59 +0200224 width = weston_log_continue("%s: ", get_atom_name(wm->conn, property));
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400225 if (reply == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +0200226 weston_log_continue("(no reply)\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400227 return;
228 }
229
Martin Minarik6d118362012-06-07 18:01:59 +0200230 width += weston_log_continue(
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400231 "%s/%d, length %d (value_len %d): ",
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400232 get_atom_name(wm->conn, reply->type),
233 reply->format,
234 xcb_get_property_value_length(reply),
235 reply->value_len);
236
237 if (reply->type == wm->atom.incr) {
238 incr_value = xcb_get_property_value(reply);
Martin Minarik6d118362012-06-07 18:01:59 +0200239 weston_log_continue("%d\n", *incr_value);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400240 } else if (reply->type == wm->atom.utf8_string ||
241 reply->type == wm->atom.string) {
242 text_value = xcb_get_property_value(reply);
243 if (reply->value_len > 40)
244 len = 40;
245 else
246 len = reply->value_len;
Martin Minarik6d118362012-06-07 18:01:59 +0200247 weston_log_continue("\"%.*s\"\n", len, text_value);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400248 } else if (reply->type == XCB_ATOM_ATOM) {
249 atom_value = xcb_get_property_value(reply);
250 for (i = 0; i < reply->value_len; i++) {
251 name = get_atom_name(wm->conn, atom_value[i]);
252 if (width + strlen(name) + 2 > 78) {
Martin Minarik6d118362012-06-07 18:01:59 +0200253 weston_log_continue("\n ");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400254 width = 4;
255 } else if (i > 0) {
Martin Minarik6d118362012-06-07 18:01:59 +0200256 width += weston_log_continue(", ");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400257 }
258
Martin Minarik6d118362012-06-07 18:01:59 +0200259 width += weston_log_continue("%s", name);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400260 }
Martin Minarik6d118362012-06-07 18:01:59 +0200261 weston_log_continue("\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400262 } else {
Martin Minarik6d118362012-06-07 18:01:59 +0200263 weston_log_continue("huh?\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400264 }
265}
266
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400267void
268read_and_dump_property(struct weston_wm *wm,
269 xcb_window_t window, xcb_atom_t property)
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400270{
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400271 xcb_get_property_reply_t *reply;
272 xcb_get_property_cookie_t cookie;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400273
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400274 cookie = xcb_get_property(wm->conn, 0, window,
275 property, XCB_ATOM_ANY, 0, 2048);
276 reply = xcb_get_property_reply(wm->conn, cookie, NULL);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400277
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400278 dump_property(wm, property, reply);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400279
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400280 free(reply);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400281}
282
283/* We reuse some predefined, but otherwise useles atoms */
284#define TYPE_WM_PROTOCOLS XCB_ATOM_CUT_BUFFER0
285#define TYPE_MOTIF_WM_HINTS XCB_ATOM_CUT_BUFFER1
286
287static void
288weston_wm_window_read_properties(struct weston_wm_window *window)
289{
290 struct weston_wm *wm = window->wm;
291
292#define F(field) offsetof(struct weston_wm_window, field)
293 const struct {
294 xcb_atom_t atom;
295 xcb_atom_t type;
296 int offset;
297 } props[] = {
298 { XCB_ATOM_WM_CLASS, XCB_ATOM_STRING, F(class) },
299 { XCB_ATOM_WM_NAME, XCB_ATOM_STRING, F(name) },
300 { XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, F(transient_for) },
301 { wm->atom.wm_protocols, TYPE_WM_PROTOCOLS, F(protocols) },
302 { wm->atom.net_wm_window_type, XCB_ATOM_ATOM, F(type) },
303 { wm->atom.net_wm_name, XCB_ATOM_STRING, F(name) },
304 { wm->atom.motif_wm_hints, TYPE_MOTIF_WM_HINTS, 0 },
305 };
306#undef F
307
308 xcb_get_property_cookie_t cookie[ARRAY_LENGTH(props)];
309 xcb_get_property_reply_t *reply;
310 void *p;
311 uint32_t *xid;
312 xcb_atom_t *atom;
313 uint32_t i;
314 struct motif_wm_hints *hints;
315
316 if (!window->properties_dirty)
317 return;
318 window->properties_dirty = 0;
319
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400320 for (i = 0; i < ARRAY_LENGTH(props); i++)
321 cookie[i] = xcb_get_property(wm->conn,
322 0, /* delete */
323 window->id,
324 props[i].atom,
325 XCB_ATOM_ANY, 0, 2048);
326
327 window->decorate = 1;
328 for (i = 0; i < ARRAY_LENGTH(props); i++) {
329 reply = xcb_get_property_reply(wm->conn, cookie[i], NULL);
330 if (!reply)
331 /* Bad window, typically */
332 continue;
333 if (reply->type == XCB_ATOM_NONE) {
334 /* No such property */
335 free(reply);
336 continue;
337 }
338
339 p = ((char *) window + props[i].offset);
340
341 switch (props[i].type) {
342 case XCB_ATOM_STRING:
343 /* FIXME: We're using this for both string and
344 utf8_string */
345 if (*(char **) p)
346 free(*(char **) p);
347
348 *(char **) p =
349 strndup(xcb_get_property_value(reply),
350 xcb_get_property_value_length(reply));
351 break;
352 case XCB_ATOM_WINDOW:
353 xid = xcb_get_property_value(reply);
354 *(struct weston_wm_window **) p =
355 hash_table_lookup(wm->window_hash, *xid);
356 break;
357 case XCB_ATOM_ATOM:
358 atom = xcb_get_property_value(reply);
359 *(xcb_atom_t *) p = *atom;
360 break;
361 case TYPE_WM_PROTOCOLS:
362 break;
363 case TYPE_MOTIF_WM_HINTS:
364 hints = xcb_get_property_value(reply);
365 if (hints->flags & MWM_HINTS_DECORATIONS)
366 window->decorate = hints->decorations > 0;
367 break;
368 default:
369 break;
370 }
371 free(reply);
372 }
373}
374
375static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400376weston_wm_window_get_frame_size(struct weston_wm_window *window,
377 int *width, int *height)
378{
379 struct theme *t = window->wm->theme;
380
381 if (window->decorate) {
382 *width = window->width + (t->margin + t->width) * 2;
383 *height = window->height +
384 t->margin * 2 + t->width + t->titlebar_height;
385 } else {
386 *width = window->width + t->margin * 2;
387 *height = window->height + t->margin * 2;
388 }
389}
390
391static void
392weston_wm_window_get_child_position(struct weston_wm_window *window,
393 int *x, int *y)
394{
395 struct theme *t = window->wm->theme;
396
397 if (window->decorate) {
398 *x = t->margin + t->width;
399 *y = t->margin + t->titlebar_height;
400 } else {
401 *x = t->margin;
402 *y = t->margin;
403 }
404}
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400405
406static void
407weston_wm_handle_configure_request(struct weston_wm *wm, xcb_generic_event_t *event)
408{
409 xcb_configure_request_event_t *configure_request =
410 (xcb_configure_request_event_t *) event;
411 struct weston_wm_window *window;
412 uint32_t mask, values[16];
413 int x, y, width, height, i = 0;
414
Martin Minarik6d118362012-06-07 18:01:59 +0200415 weston_log("XCB_CONFIGURE_REQUEST (window %d) %d,%d @ %dx%d\n",
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400416 configure_request->window,
417 configure_request->x, configure_request->y,
418 configure_request->width, configure_request->height);
419
420 window = hash_table_lookup(wm->window_hash, configure_request->window);
421
422 if (configure_request->value_mask & XCB_CONFIG_WINDOW_WIDTH)
423 window->width = configure_request->width;
424 if (configure_request->value_mask & XCB_CONFIG_WINDOW_HEIGHT)
425 window->height = configure_request->height;
426
427 weston_wm_window_get_child_position(window, &x, &y);
428 values[i++] = x;
429 values[i++] = y;
430 values[i++] = window->width;
431 values[i++] = window->height;
432 values[i++] = 0;
433 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
434 XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
435 XCB_CONFIG_WINDOW_BORDER_WIDTH;
436 if (configure_request->value_mask & XCB_CONFIG_WINDOW_SIBLING) {
437 values[i++] = configure_request->sibling;
438 mask |= XCB_CONFIG_WINDOW_SIBLING;
439 }
440 if (configure_request->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
441 values[i++] = configure_request->stack_mode;
442 mask |= XCB_CONFIG_WINDOW_STACK_MODE;
443 }
444
445 xcb_configure_window(wm->conn, window->id, mask, values);
446
447 weston_wm_window_get_frame_size(window, &width, &height);
448 values[0] = width;
449 values[1] = height;
450 mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
451 xcb_configure_window(wm->conn, window->frame_id, mask, values);
452
453 weston_wm_window_schedule_repaint(window);
454}
455
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400456static void
457weston_wm_handle_configure_notify(struct weston_wm *wm, xcb_generic_event_t *event)
458{
459 xcb_configure_notify_event_t *configure_notify =
460 (xcb_configure_notify_event_t *) event;
461 struct weston_wm_window *window;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400462
463 window = hash_table_lookup(wm->window_hash, configure_notify->window);
464
Martin Minarik6d118362012-06-07 18:01:59 +0200465 weston_log("XCB_CONFIGURE_NOTIFY (%s window %d) %d,%d @ %dx%d\n",
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400466 configure_notify->window == window->id ? "client" : "frame",
467 configure_notify->window,
468 configure_notify->x, configure_notify->y,
469 configure_notify->width, configure_notify->height);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400470}
471
472static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400473weston_wm_window_activate(struct wl_listener *listener, void *data)
474{
475 struct weston_surface *surface = data;
476 struct weston_wm_window *window = get_wm_window(surface);
Scott Moreau85ecac02012-05-21 15:49:14 -0600477 struct weston_wm *wm =
478 container_of(listener, struct weston_wm, activate_listener);
479 xcb_client_message_event_t client_message;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400480
Scott Moreau85ecac02012-05-21 15:49:14 -0600481 if (window) {
482 client_message.response_type = XCB_CLIENT_MESSAGE;
483 client_message.format = 32;
484 client_message.window = window->id;
485 client_message.type = wm->atom.wm_protocols;
486 client_message.data.data32[0] = wm->atom.wm_take_focus;
487 client_message.data.data32[1] = XCB_TIME_CURRENT_TIME;
488
489 xcb_send_event(wm->conn, 0, window->id,
490 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
491 (char *) &client_message);
492
493 xcb_set_input_focus (wm->conn, XCB_INPUT_FOCUS_POINTER_ROOT,
494 window->id, XCB_TIME_CURRENT_TIME);
495 } else {
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400496 xcb_set_input_focus (wm->conn,
497 XCB_INPUT_FOCUS_POINTER_ROOT,
498 XCB_NONE,
499 XCB_TIME_CURRENT_TIME);
Scott Moreau85ecac02012-05-21 15:49:14 -0600500 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400501
502 if (wm->focus_window)
503 weston_wm_window_schedule_repaint(wm->focus_window);
504 wm->focus_window = window;
505 if (wm->focus_window)
506 weston_wm_window_schedule_repaint(wm->focus_window);
507}
508
509static int
510our_resource(struct weston_wm *wm, uint32_t id)
511{
512 const xcb_setup_t *setup;
513
514 setup = xcb_get_setup(wm->conn);
515
516 return (id & ~setup->resource_id_mask) == setup->resource_id_base;
517}
518
Kristian Høgsberga6d9a5e2012-05-30 12:15:44 -0400519#define ICCCM_WITHDRAWN_STATE 0
520#define ICCCM_NORMAL_STATE 1
521#define ICCCM_ICONIC_STATE 3
522
523static void
524weston_wm_window_set_state(struct weston_wm_window *window, int32_t state)
525{
526 struct weston_wm *wm = window->wm;
527 uint32_t property[2];
528
529 property[0] = state;
530 property[1] = XCB_WINDOW_NONE;
531
532 xcb_change_property(wm->conn,
533 XCB_PROP_MODE_REPLACE,
534 window->id,
535 wm->atom.wm_state,
536 wm->atom.wm_state,
537 32, /* format */
538 2, property);
539}
540
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400541static void
542weston_wm_handle_map_request(struct weston_wm *wm, xcb_generic_event_t *event)
543{
544 xcb_map_request_event_t *map_request =
545 (xcb_map_request_event_t *) event;
546 struct weston_wm_window *window;
547 uint32_t values[1];
548 int x, y, width, height;
549
550 if (our_resource(wm, map_request->window)) {
Martin Minarik6d118362012-06-07 18:01:59 +0200551 weston_log("XCB_MAP_REQUEST (window %d, ours)\n",
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400552 map_request->window);
553 return;
554 }
555
556 window = hash_table_lookup(wm->window_hash, map_request->window);
557
Kristian Høgsbergbc6e1622012-05-30 09:59:56 -0400558 if (window->frame_id)
559 return;
560
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400561 weston_wm_window_read_properties(window);
562
563 weston_wm_window_get_frame_size(window, &width, &height);
564 weston_wm_window_get_child_position(window, &x, &y);
565
566 values[0] =
567 XCB_EVENT_MASK_KEY_PRESS |
568 XCB_EVENT_MASK_KEY_RELEASE |
569 XCB_EVENT_MASK_BUTTON_PRESS |
570 XCB_EVENT_MASK_BUTTON_RELEASE |
Tiago Vignatti236b48d2012-07-16 12:09:19 -0400571 XCB_EVENT_MASK_POINTER_MOTION |
572 XCB_EVENT_MASK_ENTER_WINDOW |
573 XCB_EVENT_MASK_LEAVE_WINDOW |
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400574 XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
Kristian Høgsberg44c20132012-05-30 10:09:21 -0400575 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400576
577 window->frame_id = xcb_generate_id(wm->conn);
578 xcb_create_window(wm->conn,
579 XCB_COPY_FROM_PARENT,
580 window->frame_id,
581 wm->screen->root,
582 0, 0,
583 width, height,
584 0,
585 XCB_WINDOW_CLASS_INPUT_OUTPUT,
586 wm->screen->root_visual,
587 XCB_CW_EVENT_MASK, values);
588 xcb_reparent_window(wm->conn, window->id, window->frame_id, x, y);
589
590 values[0] = 0;
591 xcb_configure_window(wm->conn, window->id,
592 XCB_CONFIG_WINDOW_BORDER_WIDTH, values);
593
Martin Minarik6d118362012-06-07 18:01:59 +0200594 weston_log("XCB_MAP_REQUEST (window %d, %p, frame %d)\n",
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400595 window->id, window, window->frame_id);
596
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400597 xcb_map_window(wm->conn, map_request->window);
598 xcb_map_window(wm->conn, window->frame_id);
Kristian Høgsberga6d9a5e2012-05-30 12:15:44 -0400599 weston_wm_window_set_state(window, ICCCM_NORMAL_STATE);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400600
601 window->cairo_surface =
602 cairo_xcb_surface_create_with_xrender_format(wm->conn,
603 wm->screen,
604 window->frame_id,
Kristian Høgsberge89cef32012-07-16 11:57:08 -0400605 &wm->format_rgb,
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400606 width, height);
607
608 hash_table_insert(wm->window_hash, window->frame_id, window);
609}
610
611static void
612weston_wm_handle_map_notify(struct weston_wm *wm, xcb_generic_event_t *event)
613{
614 xcb_map_notify_event_t *map_notify = (xcb_map_notify_event_t *) event;
615
616 if (our_resource(wm, map_notify->window)) {
Martin Minarik6d118362012-06-07 18:01:59 +0200617 weston_log("XCB_MAP_NOTIFY (window %d, ours)\n",
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400618 map_notify->window);
619 return;
620 }
621
Martin Minarik6d118362012-06-07 18:01:59 +0200622 weston_log("XCB_MAP_NOTIFY (window %d)\n", map_notify->window);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400623}
624
625static void
Kristian Høgsberg194ea542012-05-30 10:05:41 -0400626weston_wm_handle_unmap_notify(struct weston_wm *wm, xcb_generic_event_t *event)
627{
628 xcb_unmap_notify_event_t *unmap_notify =
629 (xcb_unmap_notify_event_t *) event;
630 struct weston_wm_window *window;
631
Martin Minarik6d118362012-06-07 18:01:59 +0200632 weston_log("XCB_UNMAP_NOTIFY (window %d, event %d%s)\n",
Kristian Høgsberg194ea542012-05-30 10:05:41 -0400633 unmap_notify->window,
634 unmap_notify->event,
635 our_resource(wm, unmap_notify->window) ? ", ours" : "");
636
637 if (our_resource(wm, unmap_notify->window))
638 return;
639
Kristian Høgsbergd64bdf42012-05-31 10:33:43 -0400640 if (unmap_notify->response_type & 0x80)
641 /* We just ignore the ICCCM 4.1.4 synthetic unmap notify
642 * as it may come in after we've destroyed the window. */
Kristian Høgsbergf197e9f2012-05-30 11:46:29 -0400643 return;
Kristian Høgsbergf197e9f2012-05-30 11:46:29 -0400644
Kristian Høgsbergd64bdf42012-05-31 10:33:43 -0400645 window = hash_table_lookup(wm->window_hash, unmap_notify->window);
Kristian Høgsberg194ea542012-05-30 10:05:41 -0400646 if (window->repaint_source)
647 wl_event_source_remove(window->repaint_source);
648 if (window->cairo_surface)
649 cairo_surface_destroy(window->cairo_surface);
650
Kristian Høgsbergbe375b32012-06-05 11:46:08 -0400651 if (window->frame_id) {
652 xcb_reparent_window(wm->conn, window->id, wm->wm_window, 0, 0);
653 xcb_destroy_window(wm->conn, window->frame_id);
654 weston_wm_window_set_state(window, ICCCM_WITHDRAWN_STATE);
655 hash_table_remove(wm->window_hash, window->frame_id);
656 window->frame_id = XCB_WINDOW_NONE;
657 }
Kristian Høgsberga6d9a5e2012-05-30 12:15:44 -0400658
Kristian Høgsberg194ea542012-05-30 10:05:41 -0400659 if (wm->focus_window == window)
660 wm->focus_window = NULL;
Kristian Høgsberg194ea542012-05-30 10:05:41 -0400661 if (window->surface)
662 wl_list_remove(&window->surface_destroy_listener.link);
663 window->surface = NULL;
664}
665
666static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400667weston_wm_window_draw_decoration(void *data)
668{
669 struct weston_wm_window *window = data;
670 struct weston_wm *wm = window->wm;
671 struct theme *t = wm->theme;
672 cairo_t *cr;
673 int x, y, width, height;
674 const char *title;
675 uint32_t flags = 0;
676
677 weston_wm_window_read_properties(window);
678
679 window->repaint_source = NULL;
680
681 weston_wm_window_get_frame_size(window, &width, &height);
682 weston_wm_window_get_child_position(window, &x, &y);
683
684 cairo_xcb_surface_set_size(window->cairo_surface, width, height);
685 cr = cairo_create(window->cairo_surface);
686
687 if (window->decorate) {
688 if (wm->focus_window == window)
689 flags |= THEME_FRAME_ACTIVE;
690
691 if (window->name)
692 title = window->name;
693 else
694 title = "untitled";
695
696 theme_render_frame(t, cr, width, height, title, flags);
697 } else {
698 cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
699 cairo_set_source_rgba(cr, 0, 0, 0, 0);
700 cairo_paint(cr);
701
702 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
703 cairo_set_source_rgba(cr, 0, 0, 0, 0.45);
704 tile_mask(cr, t->shadow, 2, 2, width + 8, height + 8, 64, 64);
705 }
706
707 cairo_destroy(cr);
708
709 if (window->surface) {
710 /* We leave an extra pixel around the X window area to
711 * make sure we don't sample from the undefined alpha
712 * channel when filtering. */
713 window->surface->opaque_rect[0] =
714 (double) (x - 1) / width;
715 window->surface->opaque_rect[1] =
716 (double) (x + window->width + 1) / width;
717 window->surface->opaque_rect[2] =
718 (double) (y - 1) / height;
719 window->surface->opaque_rect[3] =
720 (double) (y + window->height + 1) / height;
721
722 pixman_region32_init_rect(&window->surface->input,
723 t->margin, t->margin,
724 width - 2 * t->margin,
725 height - 2 * t->margin);
726 }
727}
728
729static void
730weston_wm_window_schedule_repaint(struct weston_wm_window *window)
731{
732 struct weston_wm *wm = window->wm;
733
734 if (window->frame_id == XCB_WINDOW_NONE || window->repaint_source)
735 return;
736
737 window->repaint_source =
738 wl_event_loop_add_idle(wm->server->loop,
739 weston_wm_window_draw_decoration,
740 window);
741}
742
743static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400744weston_wm_handle_property_notify(struct weston_wm *wm, xcb_generic_event_t *event)
745{
746 xcb_property_notify_event_t *property_notify =
747 (xcb_property_notify_event_t *) event;
748 struct weston_wm_window *window;
749
750 window = hash_table_lookup(wm->window_hash, property_notify->window);
751 if (window)
752 window->properties_dirty = 1;
753
Martin Minarik6d118362012-06-07 18:01:59 +0200754 weston_log("XCB_PROPERTY_NOTIFY: window %d, ",
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400755 property_notify->window);
Kristian Høgsberge244cb02012-05-30 11:34:35 -0400756 if (property_notify->state == XCB_PROPERTY_DELETE)
Martin Minarik6d118362012-06-07 18:01:59 +0200757 weston_log("deleted\n");
Kristian Høgsberge244cb02012-05-30 11:34:35 -0400758 else
759 read_and_dump_property(wm, property_notify->window,
760 property_notify->atom);
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400761
762 if (property_notify->atom == wm->atom.net_wm_name ||
763 property_notify->atom == XCB_ATOM_WM_NAME)
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400764 weston_wm_window_schedule_repaint(window);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400765}
766
767static void
Kristian Høgsberg029539b2012-05-30 11:28:24 -0400768weston_wm_window_create(struct weston_wm *wm,
Tiago Vignatti771241e2012-06-04 20:01:45 +0300769 xcb_window_t id, int width, int height, int override)
Kristian Høgsberg029539b2012-05-30 11:28:24 -0400770{
771 struct weston_wm_window *window;
772 uint32_t values[1];
773
774 window = malloc(sizeof *window);
775 if (window == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +0200776 weston_log("failed to allocate window\n");
Kristian Høgsberg029539b2012-05-30 11:28:24 -0400777 return;
778 }
779
780 values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE;
781 xcb_change_window_attributes(wm->conn, id, XCB_CW_EVENT_MASK, values);
782
783 memset(window, 0, sizeof *window);
784 window->wm = wm;
785 window->id = id;
786 window->properties_dirty = 1;
Tiago Vignatti771241e2012-06-04 20:01:45 +0300787 window->override_redirect = override;
Kristian Høgsberg029539b2012-05-30 11:28:24 -0400788 window->width = width;
789 window->height = height;
790
791 hash_table_insert(wm->window_hash, id, window);
792}
793
794static void
795weston_wm_window_destroy(struct weston_wm_window *window)
796{
797 hash_table_remove(window->wm->window_hash, window->id);
798 free(window);
799}
800
801static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400802weston_wm_handle_create_notify(struct weston_wm *wm, xcb_generic_event_t *event)
803{
804 xcb_create_notify_event_t *create_notify =
805 (xcb_create_notify_event_t *) event;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400806
Martin Minarik6d118362012-06-07 18:01:59 +0200807 weston_log("XCB_CREATE_NOTIFY (window %d, width %d, height %d%s%s)\n",
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400808 create_notify->window,
809 create_notify->width, create_notify->height,
810 create_notify->override_redirect ? ", override" : "",
811 our_resource(wm, create_notify->window) ? ", ours" : "");
812
813 if (our_resource(wm, create_notify->window))
814 return;
815
Kristian Høgsberg029539b2012-05-30 11:28:24 -0400816 weston_wm_window_create(wm, create_notify->window,
Tiago Vignatti771241e2012-06-04 20:01:45 +0300817 create_notify->width, create_notify->height,
818 create_notify->override_redirect);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400819}
820
821static void
822weston_wm_handle_destroy_notify(struct weston_wm *wm, xcb_generic_event_t *event)
823{
824 xcb_destroy_notify_event_t *destroy_notify =
825 (xcb_destroy_notify_event_t *) event;
826 struct weston_wm_window *window;
827
Martin Minarik6d118362012-06-07 18:01:59 +0200828 weston_log("XCB_DESTROY_NOTIFY, win %d, event %d%s\n",
Kristian Høgsberg194ea542012-05-30 10:05:41 -0400829 destroy_notify->window,
830 destroy_notify->event,
831 our_resource(wm, destroy_notify->window) ? ", ours" : "");
832
833 if (our_resource(wm, destroy_notify->window))
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400834 return;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400835
836 window = hash_table_lookup(wm->window_hash, destroy_notify->window);
Kristian Høgsberg029539b2012-05-30 11:28:24 -0400837 weston_wm_window_destroy(window);
838}
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400839
Kristian Høgsberg029539b2012-05-30 11:28:24 -0400840static void
841weston_wm_handle_reparent_notify(struct weston_wm *wm, xcb_generic_event_t *event)
842{
843 xcb_reparent_notify_event_t *reparent_notify =
844 (xcb_reparent_notify_event_t *) event;
845 struct weston_wm_window *window;
Kristian Høgsbergc9571fb2012-05-29 15:35:29 -0400846
Martin Minarik6d118362012-06-07 18:01:59 +0200847 weston_log("XCB_REPARENT_NOTIFY (window %d, parent %d, event %d)\n",
Kristian Høgsberg029539b2012-05-30 11:28:24 -0400848 reparent_notify->window,
849 reparent_notify->parent,
850 reparent_notify->event);
851
852 if (reparent_notify->parent == wm->screen->root) {
Tiago Vignatti771241e2012-06-04 20:01:45 +0300853 weston_wm_window_create(wm, reparent_notify->window, 10, 10,
854 reparent_notify->override_redirect);
Kristian Høgsberg029539b2012-05-30 11:28:24 -0400855 } else if (!our_resource(wm, reparent_notify->parent)) {
856 window = hash_table_lookup(wm->window_hash,
857 reparent_notify->window);
858 weston_wm_window_destroy(window);
859 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400860}
861
862static void
Kristian Høgsberge68fd102012-05-22 17:09:40 -0400863weston_wm_window_handle_moveresize(struct weston_wm_window *window,
864 xcb_client_message_event_t *client_message)
865{
866 static const int map[] = {
867 THEME_LOCATION_RESIZING_TOP_LEFT,
868 THEME_LOCATION_RESIZING_TOP,
869 THEME_LOCATION_RESIZING_TOP_RIGHT,
870 THEME_LOCATION_RESIZING_RIGHT,
871 THEME_LOCATION_RESIZING_BOTTOM_RIGHT,
872 THEME_LOCATION_RESIZING_BOTTOM,
873 THEME_LOCATION_RESIZING_BOTTOM_LEFT,
874 THEME_LOCATION_RESIZING_LEFT
875 };
876
877 struct weston_wm *wm = window->wm;
878 struct weston_seat *seat = wm->server->compositor->seat;
879 int detail;
880 struct weston_shell_interface *shell_interface =
881 &wm->server->compositor->shell_interface;
882
883 if (seat->seat.pointer->button_count != 1 ||
884 seat->seat.pointer->focus != &window->surface->surface)
885 return;
886
887 detail = client_message->data.data32[2];
888 switch (detail) {
889 case _NET_WM_MOVERESIZE_MOVE:
890 shell_interface->move(window->shsurf, seat);
891 break;
892 case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
893 case _NET_WM_MOVERESIZE_SIZE_TOP:
894 case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
895 case _NET_WM_MOVERESIZE_SIZE_RIGHT:
896 case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
897 case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
898 case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
899 case _NET_WM_MOVERESIZE_SIZE_LEFT:
900 shell_interface->resize(window->shsurf, seat, map[detail]);
901 break;
902 case _NET_WM_MOVERESIZE_CANCEL:
903 break;
904 }
905}
906
907static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400908weston_wm_handle_client_message(struct weston_wm *wm,
909 xcb_generic_event_t *event)
910{
911 xcb_client_message_event_t *client_message =
912 (xcb_client_message_event_t *) event;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400913 struct weston_wm_window *window;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400914
915 window = hash_table_lookup(wm->window_hash, client_message->window);
916
Martin Minarik6d118362012-06-07 18:01:59 +0200917 weston_log("XCB_CLIENT_MESSAGE (%s %d %d %d %d %d)\n",
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400918 get_atom_name(wm->conn, client_message->type),
919 client_message->data.data32[0],
920 client_message->data.data32[1],
921 client_message->data.data32[2],
922 client_message->data.data32[3],
923 client_message->data.data32[4]);
924
Kristian Høgsberge68fd102012-05-22 17:09:40 -0400925 if (client_message->type == wm->atom.net_wm_moveresize)
926 weston_wm_window_handle_moveresize(window, client_message);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400927}
928
Tiago Vignatti236b48d2012-07-16 12:09:19 -0400929enum cursor_type {
930 XWM_CURSOR_TOP,
931 XWM_CURSOR_BOTTOM,
932 XWM_CURSOR_LEFT,
933 XWM_CURSOR_RIGHT,
934 XWM_CURSOR_TOP_LEFT,
935 XWM_CURSOR_TOP_RIGHT,
936 XWM_CURSOR_BOTTOM_LEFT,
937 XWM_CURSOR_BOTTOM_RIGHT,
938 XWM_CURSOR_LEFT_PTR,
939};
940
941static const char *cursors[] = {
942 "top_side",
943 "bottom_side",
944 "left_side",
945 "right_side",
946 "top_left_corner",
947 "top_right_corner",
948 "bottom_left_corner",
949 "bottom_right_corner",
950 "left_ptr"
951};
952
953static void
954weston_wm_create_cursors(struct weston_wm *wm)
955{
956 int i, count = ARRAY_LENGTH(cursors);
957
958 wm->cursors = malloc(count * sizeof(xcb_cursor_t));
959 for (i = 0; i < count; i++) {
960 wm->cursors[i] =
961 xcb_cursor_library_load_cursor(wm, cursors[i]);
962 }
963
964 wm->last_cursor = -1;
965}
966
967static void
968weston_wm_destroy_cursors(struct weston_wm *wm)
969{
970 uint8_t i;
971
972 for (i = 0; i < ARRAY_LENGTH(cursors); i++)
973 xcb_free_cursor(wm->conn, wm->cursors[i]);
974
975 free(wm->cursors);
976}
977
978static int
979get_cursor_for_location(struct theme *t, int width, int height, int x, int y)
980{
981 int location = theme_get_location(t, x, y, width, height);
982
983 switch (location) {
984 case THEME_LOCATION_RESIZING_TOP:
985 return XWM_CURSOR_TOP;
986 case THEME_LOCATION_RESIZING_BOTTOM:
987 return XWM_CURSOR_BOTTOM;
988 case THEME_LOCATION_RESIZING_LEFT:
989 return XWM_CURSOR_LEFT;
990 case THEME_LOCATION_RESIZING_RIGHT:
991 return XWM_CURSOR_RIGHT;
992 case THEME_LOCATION_RESIZING_TOP_LEFT:
993 return XWM_CURSOR_TOP_LEFT;
994 case THEME_LOCATION_RESIZING_TOP_RIGHT:
995 return XWM_CURSOR_TOP_RIGHT;
996 case THEME_LOCATION_RESIZING_BOTTOM_LEFT:
997 return XWM_CURSOR_BOTTOM_LEFT;
998 case THEME_LOCATION_RESIZING_BOTTOM_RIGHT:
999 return XWM_CURSOR_BOTTOM_RIGHT;
1000 case THEME_LOCATION_EXTERIOR:
1001 case THEME_LOCATION_TITLEBAR:
1002 default:
1003 return XWM_CURSOR_LEFT_PTR;
1004 }
1005}
1006
1007static void
1008weston_wm_frame_set_cursor(struct weston_wm *wm,
1009 struct weston_wm_window *window, int cursor)
1010{
1011 uint32_t cursor_value_list;
1012
1013 if (!window->frame_id)
1014 return;
1015
1016 if (wm->last_cursor == cursor)
1017 return;
1018
1019 wm->last_cursor = cursor;
1020
1021 cursor_value_list = wm->cursors[cursor];
1022 xcb_change_window_attributes (wm->conn, window->frame_id,
1023 XCB_CW_CURSOR, &cursor_value_list);
1024 xcb_flush(wm->conn);
1025}
1026
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001027static void
1028weston_wm_handle_button(struct weston_wm *wm, xcb_generic_event_t *event)
1029{
1030 xcb_button_press_event_t *button = (xcb_button_press_event_t *) event;
1031 struct weston_shell_interface *shell_interface =
1032 &wm->server->compositor->shell_interface;
1033 struct weston_wm_window *window;
Kristian Høgsbergf96e6c02012-05-22 16:38:53 -04001034 enum theme_location location;
1035 struct theme *t = wm->theme;
Kristian Høgsbergc1693f22012-05-22 16:56:23 -04001036 int width, height;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001037
Martin Minarik6d118362012-06-07 18:01:59 +02001038 weston_log("XCB_BUTTON_%s (detail %d)\n",
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001039 button->response_type == XCB_BUTTON_PRESS ?
1040 "PRESS" : "RELEASE", button->detail);
1041
1042 window = hash_table_lookup(wm->window_hash, button->event);
Kristian Høgsbergc1693f22012-05-22 16:56:23 -04001043 weston_wm_window_get_frame_size(window, &width, &height);
1044
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001045 if (button->response_type == XCB_BUTTON_PRESS &&
Kristian Høgsbergf96e6c02012-05-22 16:38:53 -04001046 button->detail == 1) {
1047 location = theme_get_location(t,
1048 button->event_x,
1049 button->event_y,
Kristian Høgsbergc1693f22012-05-22 16:56:23 -04001050 width, height);
Kristian Høgsbergf96e6c02012-05-22 16:38:53 -04001051
1052 switch (location) {
1053 case THEME_LOCATION_TITLEBAR:
1054 shell_interface->move(window->shsurf,
1055 wm->server->compositor->seat);
1056 break;
Kristian Høgsbergc1693f22012-05-22 16:56:23 -04001057 case THEME_LOCATION_RESIZING_TOP:
1058 case THEME_LOCATION_RESIZING_BOTTOM:
1059 case THEME_LOCATION_RESIZING_LEFT:
1060 case THEME_LOCATION_RESIZING_RIGHT:
1061 case THEME_LOCATION_RESIZING_TOP_LEFT:
1062 case THEME_LOCATION_RESIZING_TOP_RIGHT:
1063 case THEME_LOCATION_RESIZING_BOTTOM_LEFT:
1064 case THEME_LOCATION_RESIZING_BOTTOM_RIGHT:
1065 shell_interface->resize(window->shsurf,
1066 wm->server->compositor->seat,
1067 location);
1068 break;
Kristian Høgsbergf96e6c02012-05-22 16:38:53 -04001069 default:
1070 break;
1071 }
1072 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001073}
1074
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001075static void
1076weston_wm_handle_motion(struct weston_wm *wm, xcb_generic_event_t *event)
1077{
1078 xcb_motion_notify_event_t *motion = (xcb_motion_notify_event_t *) event;
1079 struct weston_wm_window *window;
1080 int cursor, width, height;
1081
1082 window = hash_table_lookup(wm->window_hash, motion->event);
1083 if (!window)
1084 return;
1085
1086 weston_wm_window_get_frame_size(window, &width, &height);
1087 cursor = get_cursor_for_location(wm->theme, width, height,
1088 motion->event_x, motion->event_y);
1089
1090 weston_wm_frame_set_cursor(wm, window, cursor);
1091}
1092
1093static void
1094weston_wm_handle_enter(struct weston_wm *wm, xcb_generic_event_t *event)
1095{
1096 xcb_enter_notify_event_t *enter = (xcb_enter_notify_event_t *) event;
1097 struct weston_wm_window *window;
1098 int cursor, width, height;
1099
1100 window = hash_table_lookup(wm->window_hash, enter->event);
1101 if (!window)
1102 return;
1103
1104 weston_wm_window_get_frame_size(window, &width, &height);
1105 cursor = get_cursor_for_location(wm->theme, width, height,
1106 enter->event_x, enter->event_y);
1107
1108 weston_wm_frame_set_cursor(wm, window, cursor);
1109}
1110
1111static void
1112weston_wm_handle_leave(struct weston_wm *wm, xcb_generic_event_t *event)
1113{
1114 xcb_leave_notify_event_t *leave = (xcb_leave_notify_event_t *) event;
1115 struct weston_wm_window *window;
1116
1117 window = hash_table_lookup(wm->window_hash, leave->event);
1118 if (!window)
1119 return;
1120
1121 weston_wm_frame_set_cursor(wm, window, XWM_CURSOR_LEFT_PTR);
1122}
1123
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001124static int
1125weston_wm_handle_event(int fd, uint32_t mask, void *data)
1126{
1127 struct weston_wm *wm = data;
1128 xcb_generic_event_t *event;
1129 int count = 0;
1130
1131 while (event = xcb_poll_for_event(wm->conn), event != NULL) {
1132 if (weston_wm_handle_selection_event(wm, event)) {
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001133 free(event);
1134 count++;
1135 continue;
1136 }
1137
Kristian Høgsbergf197e9f2012-05-30 11:46:29 -04001138 switch (event->response_type & ~0x80) {
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001139 case XCB_BUTTON_PRESS:
1140 case XCB_BUTTON_RELEASE:
1141 weston_wm_handle_button(wm, event);
1142 break;
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001143 case XCB_ENTER_NOTIFY:
1144 weston_wm_handle_enter(wm, event);
1145 break;
1146 case XCB_LEAVE_NOTIFY:
1147 weston_wm_handle_leave(wm, event);
1148 break;
1149 case XCB_MOTION_NOTIFY:
1150 weston_wm_handle_motion(wm, event);
1151 break;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001152 case XCB_CREATE_NOTIFY:
1153 weston_wm_handle_create_notify(wm, event);
1154 break;
1155 case XCB_MAP_REQUEST:
1156 weston_wm_handle_map_request(wm, event);
1157 break;
1158 case XCB_MAP_NOTIFY:
1159 weston_wm_handle_map_notify(wm, event);
1160 break;
1161 case XCB_UNMAP_NOTIFY:
Kristian Høgsberg194ea542012-05-30 10:05:41 -04001162 weston_wm_handle_unmap_notify(wm, event);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001163 break;
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001164 case XCB_REPARENT_NOTIFY:
1165 weston_wm_handle_reparent_notify(wm, event);
1166 break;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001167 case XCB_CONFIGURE_REQUEST:
1168 weston_wm_handle_configure_request(wm, event);
1169 break;
1170 case XCB_CONFIGURE_NOTIFY:
1171 weston_wm_handle_configure_notify(wm, event);
1172 break;
1173 case XCB_DESTROY_NOTIFY:
1174 weston_wm_handle_destroy_notify(wm, event);
1175 break;
1176 case XCB_MAPPING_NOTIFY:
Martin Minarik6d118362012-06-07 18:01:59 +02001177 weston_log("XCB_MAPPING_NOTIFY\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001178 break;
1179 case XCB_PROPERTY_NOTIFY:
1180 weston_wm_handle_property_notify(wm, event);
1181 break;
1182 case XCB_CLIENT_MESSAGE:
1183 weston_wm_handle_client_message(wm, event);
1184 break;
1185 }
1186
1187 free(event);
1188 count++;
1189 }
1190
1191 xcb_flush(wm->conn);
1192
1193 return count;
1194}
1195
1196static void
1197wxs_wm_get_resources(struct weston_wm *wm)
1198{
1199
1200#define F(field) offsetof(struct weston_wm, field)
1201
1202 static const struct { const char *name; int offset; } atoms[] = {
1203 { "WM_PROTOCOLS", F(atom.wm_protocols) },
1204 { "WM_TAKE_FOCUS", F(atom.wm_take_focus) },
1205 { "WM_DELETE_WINDOW", F(atom.wm_delete_window) },
Kristian Høgsberga6d9a5e2012-05-30 12:15:44 -04001206 { "WM_STATE", F(atom.wm_state) },
Kristian Høgsberg670b5d32012-06-04 11:00:40 -04001207 { "WM_S0", F(atom.wm_s0) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001208 { "_NET_WM_NAME", F(atom.net_wm_name) },
1209 { "_NET_WM_ICON", F(atom.net_wm_icon) },
1210 { "_NET_WM_STATE", F(atom.net_wm_state) },
1211 { "_NET_WM_STATE_FULLSCREEN", F(atom.net_wm_state_fullscreen) },
1212 { "_NET_WM_USER_TIME", F(atom.net_wm_user_time) },
1213 { "_NET_WM_ICON_NAME", F(atom.net_wm_icon_name) },
1214 { "_NET_WM_WINDOW_TYPE", F(atom.net_wm_window_type) },
1215
1216 { "_NET_WM_WINDOW_TYPE_DESKTOP", F(atom.net_wm_window_type_desktop) },
1217 { "_NET_WM_WINDOW_TYPE_DOCK", F(atom.net_wm_window_type_dock) },
1218 { "_NET_WM_WINDOW_TYPE_TOOLBAR", F(atom.net_wm_window_type_toolbar) },
1219 { "_NET_WM_WINDOW_TYPE_MENU", F(atom.net_wm_window_type_menu) },
1220 { "_NET_WM_WINDOW_TYPE_UTILITY", F(atom.net_wm_window_type_utility) },
1221 { "_NET_WM_WINDOW_TYPE_SPLASH", F(atom.net_wm_window_type_splash) },
1222 { "_NET_WM_WINDOW_TYPE_DIALOG", F(atom.net_wm_window_type_dialog) },
Tiago Vignattibf1e8662012-06-12 14:07:49 +03001223 { "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", F(atom.net_wm_window_type_dropdown) },
1224 { "_NET_WM_WINDOW_TYPE_POPUP_MENU", F(atom.net_wm_window_type_popup) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001225 { "_NET_WM_WINDOW_TYPE_TOOLTIP", F(atom.net_wm_window_type_tooltip) },
1226 { "_NET_WM_WINDOW_TYPE_NOTIFICATION", F(atom.net_wm_window_type_notification) },
1227 { "_NET_WM_WINDOW_TYPE_COMBO", F(atom.net_wm_window_type_combo) },
1228 { "_NET_WM_WINDOW_TYPE_DND", F(atom.net_wm_window_type_dnd) },
1229 { "_NET_WM_WINDOW_TYPE_NORMAL", F(atom.net_wm_window_type_normal) },
1230
1231 { "_NET_WM_MOVERESIZE", F(atom.net_wm_moveresize) },
1232 { "_NET_SUPPORTING_WM_CHECK",
1233 F(atom.net_supporting_wm_check) },
1234 { "_NET_SUPPORTED", F(atom.net_supported) },
1235 { "_MOTIF_WM_HINTS", F(atom.motif_wm_hints) },
1236 { "CLIPBOARD", F(atom.clipboard) },
Kristian Høgsbergcba022a2012-06-04 10:11:45 -04001237 { "CLIPBOARD_MANAGER", F(atom.clipboard_manager) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001238 { "TARGETS", F(atom.targets) },
1239 { "UTF8_STRING", F(atom.utf8_string) },
1240 { "_WL_SELECTION", F(atom.wl_selection) },
1241 { "INCR", F(atom.incr) },
1242 { "TIMESTAMP", F(atom.timestamp) },
1243 { "MULTIPLE", F(atom.multiple) },
1244 { "UTF8_STRING" , F(atom.utf8_string) },
1245 { "COMPOUND_TEXT", F(atom.compound_text) },
1246 { "TEXT", F(atom.text) },
1247 { "STRING", F(atom.string) },
1248 { "text/plain;charset=utf-8", F(atom.text_plain_utf8) },
1249 { "text/plain", F(atom.text_plain) },
1250 };
1251#undef F
1252
1253 xcb_xfixes_query_version_cookie_t xfixes_cookie;
1254 xcb_xfixes_query_version_reply_t *xfixes_reply;
1255 xcb_intern_atom_cookie_t cookies[ARRAY_LENGTH(atoms)];
1256 xcb_intern_atom_reply_t *reply;
1257 xcb_render_query_pict_formats_reply_t *formats_reply;
1258 xcb_render_query_pict_formats_cookie_t formats_cookie;
1259 xcb_render_pictforminfo_t *formats;
1260 uint32_t i;
1261
1262 xcb_prefetch_extension_data (wm->conn, &xcb_xfixes_id);
1263
1264 formats_cookie = xcb_render_query_pict_formats(wm->conn);
1265
1266 for (i = 0; i < ARRAY_LENGTH(atoms); i++)
1267 cookies[i] = xcb_intern_atom (wm->conn, 0,
1268 strlen(atoms[i].name),
1269 atoms[i].name);
1270
1271 for (i = 0; i < ARRAY_LENGTH(atoms); i++) {
1272 reply = xcb_intern_atom_reply (wm->conn, cookies[i], NULL);
1273 *(xcb_atom_t *) ((char *) wm + atoms[i].offset) = reply->atom;
1274 free(reply);
1275 }
1276
1277 wm->xfixes = xcb_get_extension_data(wm->conn, &xcb_xfixes_id);
1278 if (!wm->xfixes || !wm->xfixes->present)
Martin Minarik6d118362012-06-07 18:01:59 +02001279 weston_log("xfixes not available\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001280
1281 xfixes_cookie = xcb_xfixes_query_version(wm->conn,
1282 XCB_XFIXES_MAJOR_VERSION,
1283 XCB_XFIXES_MINOR_VERSION);
1284 xfixes_reply = xcb_xfixes_query_version_reply(wm->conn,
1285 xfixes_cookie, NULL);
1286
Martin Minarik6d118362012-06-07 18:01:59 +02001287 weston_log("xfixes version: %d.%d\n",
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001288 xfixes_reply->major_version, xfixes_reply->minor_version);
1289
1290 free(xfixes_reply);
1291
1292 formats_reply = xcb_render_query_pict_formats_reply(wm->conn,
1293 formats_cookie, 0);
1294 if (formats_reply == NULL)
1295 return;
1296
1297 formats = xcb_render_query_pict_formats_formats(formats_reply);
Kristian Høgsberge89cef32012-07-16 11:57:08 -04001298 for (i = 0; i < formats_reply->num_formats; i++) {
1299 if (formats[i].direct.red_mask != 0xff &&
1300 formats[i].direct.red_shift != 16)
1301 continue;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001302 if (formats[i].type == XCB_RENDER_PICT_TYPE_DIRECT &&
1303 formats[i].depth == 24)
Kristian Høgsberge89cef32012-07-16 11:57:08 -04001304 wm->format_rgb = formats[i];
1305 if (formats[i].type == XCB_RENDER_PICT_TYPE_DIRECT &&
1306 formats[i].depth == 32 &&
1307 formats[i].direct.alpha_mask == 0xff &&
1308 formats[i].direct.alpha_shift == 24)
1309 wm->format_rgba = formats[i];
1310 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001311
1312 free(formats_reply);
1313}
1314
1315static void
1316weston_wm_create_wm_window(struct weston_wm *wm)
1317{
1318 static const char name[] = "Weston WM";
1319
1320 wm->wm_window = xcb_generate_id(wm->conn);
1321 xcb_create_window(wm->conn,
1322 XCB_COPY_FROM_PARENT,
1323 wm->wm_window,
1324 wm->screen->root,
1325 0, 0,
1326 10, 10,
1327 0,
1328 XCB_WINDOW_CLASS_INPUT_OUTPUT,
1329 wm->screen->root_visual,
1330 0, NULL);
1331
1332 xcb_change_property(wm->conn,
1333 XCB_PROP_MODE_REPLACE,
1334 wm->wm_window,
1335 wm->atom.net_supporting_wm_check,
1336 XCB_ATOM_WINDOW,
1337 32, /* format */
1338 1, &wm->wm_window);
1339
1340 xcb_change_property(wm->conn,
1341 XCB_PROP_MODE_REPLACE,
1342 wm->wm_window,
1343 wm->atom.net_wm_name,
1344 wm->atom.utf8_string,
1345 8, /* format */
1346 strlen(name), name);
1347
1348 xcb_change_property(wm->conn,
1349 XCB_PROP_MODE_REPLACE,
1350 wm->screen->root,
1351 wm->atom.net_supporting_wm_check,
1352 XCB_ATOM_WINDOW,
1353 32, /* format */
1354 1, &wm->wm_window);
1355
Kristian Høgsberg670b5d32012-06-04 11:00:40 -04001356 /* Claim the WM_S0 selection even though we don't suport
1357 * the --replace functionality. */
1358 xcb_set_selection_owner(wm->conn,
1359 wm->wm_window,
1360 wm->atom.wm_s0,
1361 XCB_TIME_CURRENT_TIME);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001362}
1363
1364struct weston_wm *
1365weston_wm_create(struct weston_xserver *wxs)
1366{
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001367 struct weston_wm *wm;
1368 struct wl_event_loop *loop;
1369 xcb_screen_iterator_t s;
Kristian Høgsberg4dec0112012-06-03 09:18:06 -04001370 uint32_t values[1];
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001371 int sv[2];
1372 xcb_atom_t supported[1];
1373
1374 wm = malloc(sizeof *wm);
1375 if (wm == NULL)
1376 return NULL;
1377
1378 memset(wm, 0, sizeof *wm);
1379 wm->server = wxs;
1380 wm->window_hash = hash_table_create();
1381 if (wm->window_hash == NULL) {
1382 free(wm);
1383 return NULL;
1384 }
1385
1386 if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02001387 weston_log("socketpair failed\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001388 hash_table_destroy(wm->window_hash);
1389 free(wm);
1390 return NULL;
1391 }
1392
1393 xserver_send_client(wxs->resource, sv[1]);
1394 wl_client_flush(wxs->resource->client);
1395 close(sv[1]);
1396
1397 /* xcb_connect_to_fd takes ownership of the fd. */
1398 wm->conn = xcb_connect_to_fd(sv[0], NULL);
1399 if (xcb_connection_has_error(wm->conn)) {
Martin Minarik6d118362012-06-07 18:01:59 +02001400 weston_log("xcb_connect_to_fd failed\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001401 close(sv[0]);
1402 hash_table_destroy(wm->window_hash);
1403 free(wm);
1404 return NULL;
1405 }
1406
1407 s = xcb_setup_roots_iterator(xcb_get_setup(wm->conn));
1408 wm->screen = s.data;
1409
1410 loop = wl_display_get_event_loop(wxs->wl_display);
1411 wm->source =
1412 wl_event_loop_add_fd(loop, sv[0],
1413 WL_EVENT_READABLE,
1414 weston_wm_handle_event, wm);
1415 wl_event_source_check(wm->source);
1416
1417 wxs_wm_get_resources(wm);
1418
1419 values[0] =
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001420 XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
1421 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT |
1422 XCB_EVENT_MASK_PROPERTY_CHANGE;
1423 xcb_change_window_attributes(wm->conn, wm->screen->root,
1424 XCB_CW_EVENT_MASK, values);
1425 wm->theme = theme_create();
1426
1427 weston_wm_create_wm_window(wm);
1428
1429 supported[0] = wm->atom.net_wm_moveresize;
1430 xcb_change_property(wm->conn,
1431 XCB_PROP_MODE_REPLACE,
1432 wm->screen->root,
1433 wm->atom.net_supported,
1434 XCB_ATOM_ATOM,
1435 32, /* format */
1436 ARRAY_LENGTH(supported), supported);
1437
Kristian Høgsberg4dec0112012-06-03 09:18:06 -04001438 weston_wm_selection_init(wm);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001439
1440 xcb_flush(wm->conn);
1441
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001442 wm->activate_listener.notify = weston_wm_window_activate;
1443 wl_signal_add(&wxs->compositor->activate_signal,
1444 &wm->activate_listener);
1445
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001446 weston_wm_create_cursors(wm);
1447
Martin Minarik6d118362012-06-07 18:01:59 +02001448 weston_log("created wm\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001449
1450 return wm;
1451}
1452
1453void
1454weston_wm_destroy(struct weston_wm *wm)
1455{
1456 /* FIXME: Free windows in hash. */
1457 hash_table_destroy(wm->window_hash);
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001458 weston_wm_destroy_cursors(wm);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001459 xcb_disconnect(wm->conn);
1460 wl_event_source_remove(wm->source);
1461 wl_list_remove(&wm->selection_listener.link);
1462 wl_list_remove(&wm->activate_listener.link);
1463
1464 free(wm);
1465}
1466
1467static void
1468surface_destroy(struct wl_listener *listener, void *data)
1469{
1470 struct weston_wm_window *window =
1471 container_of(listener,
1472 struct weston_wm_window, surface_destroy_listener);
1473
Martin Minarik6d118362012-06-07 18:01:59 +02001474 weston_log("surface for xid %d destroyed\n", window->id);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001475}
1476
1477static struct weston_wm_window *
1478get_wm_window(struct weston_surface *surface)
1479{
1480 struct wl_resource *resource = &surface->surface.resource;
1481 struct wl_listener *listener;
1482
1483 listener = wl_signal_get(&resource->destroy_signal, surface_destroy);
1484 if (listener)
1485 return container_of(listener, struct weston_wm_window,
1486 surface_destroy_listener);
1487
1488 return NULL;
1489}
1490
1491static void
Kristian Høgsberga61ca062012-05-22 16:05:52 -04001492weston_wm_window_configure(void *data)
1493{
1494 struct weston_wm_window *window = data;
1495 struct weston_wm *wm = window->wm;
1496 uint32_t values[2];
1497 int width, height;
1498
1499 values[0] = window->width;
1500 values[1] = window->height;
1501 xcb_configure_window(wm->conn,
1502 window->id,
1503 XCB_CONFIG_WINDOW_WIDTH |
1504 XCB_CONFIG_WINDOW_HEIGHT,
1505 values);
1506
1507 weston_wm_window_get_frame_size(window, &width, &height);
1508 values[0] = width;
1509 values[1] = height;
1510 xcb_configure_window(wm->conn,
1511 window->frame_id,
1512 XCB_CONFIG_WINDOW_WIDTH |
1513 XCB_CONFIG_WINDOW_HEIGHT,
1514 values);
1515
1516 window->configure_source = NULL;
1517
1518 weston_wm_window_schedule_repaint(window);
1519}
1520
1521static void
1522send_configure(struct weston_surface *surface,
1523 uint32_t edges, int32_t width, int32_t height)
1524{
1525 struct weston_wm_window *window = get_wm_window(surface);
1526 struct weston_wm *wm = window->wm;
1527 struct theme *t = window->wm->theme;
1528
1529 if (window->decorate) {
1530 window->width = width - 2 * (t->margin + t->width);
1531 window->height = height - 2 * t->margin -
1532 t->titlebar_height - t->width;
1533 } else {
1534 window->width = width - 2 * t->margin;
1535 window->height = height - 2 * t->margin;
1536 }
1537
1538 if (window->configure_source)
1539 return;
1540
1541 window->configure_source =
1542 wl_event_loop_add_idle(wm->server->loop,
1543 weston_wm_window_configure, window);
1544}
1545
1546static const struct weston_shell_client shell_client = {
1547 send_configure
1548};
1549
1550static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001551xserver_map_shell_surface(struct weston_wm *wm,
1552 struct weston_wm_window *window)
1553{
1554 struct weston_shell_interface *shell_interface =
1555 &wm->server->compositor->shell_interface;
1556 struct weston_wm_window *parent;
1557 struct theme *t = window->wm->theme;
1558
1559 if (!shell_interface->create_shell_surface)
1560 return;
1561
1562 window->shsurf =
1563 shell_interface->create_shell_surface(shell_interface->shell,
Kristian Høgsberga61ca062012-05-22 16:05:52 -04001564 window->surface,
1565 &shell_client);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001566
Tiago Vignatti771241e2012-06-04 20:01:45 +03001567 /* ICCCM 4.1.1 */
Kristian Høgsbergcd80f102012-06-15 15:40:18 -04001568 if (!window->override_redirect || !window->transient_for) {
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001569 shell_interface->set_toplevel(window->shsurf);
1570 return;
1571 }
1572
1573 parent = hash_table_lookup(wm->window_hash, window->transient_for->id);
Kristian Høgsberg8150b192012-06-27 10:22:58 -04001574 shell_interface->set_transient(window->shsurf, parent->surface,
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001575 window->x - parent->x + t->margin + t->width,
1576 window->y - parent->y + t->margin + t->titlebar_height,
1577 WL_SHELL_SURFACE_TRANSIENT_INACTIVE);
1578}
1579
1580static void
1581xserver_set_window_id(struct wl_client *client, struct wl_resource *resource,
1582 struct wl_resource *surface_resource, uint32_t id)
1583{
1584 struct weston_xserver *wxs = resource->data;
1585 struct weston_wm *wm = wxs->wm;
1586 struct wl_surface *surface = surface_resource->data;
1587 struct weston_wm_window *window;
1588
1589 if (client != wxs->client)
1590 return;
1591
1592 window = hash_table_lookup(wm->window_hash, id);
1593 if (window == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02001594 weston_log("set_window_id for unknown window %d\n", id);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001595 return;
1596 }
1597
Martin Minarik6d118362012-06-07 18:01:59 +02001598 weston_log("set_window_id %d for surface %p\n", id, surface);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001599
1600 weston_wm_window_read_properties(window);
1601
1602 window->surface = (struct weston_surface *) surface;
1603 window->surface_destroy_listener.notify = surface_destroy;
1604 wl_signal_add(&surface->resource.destroy_signal,
1605 &window->surface_destroy_listener);
1606
1607 weston_wm_window_schedule_repaint(window);
1608 xserver_map_shell_surface(wm, window);
1609}
1610
1611const struct xserver_interface xserver_implementation = {
1612 xserver_set_window_id
1613};