blob: d56eddd848457d431ffaf624a1244df5dc0d4652 [file] [log] [blame]
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001/*
2 * Copyright © 2011 Intel Corporation
3 *
Bryce Harrington0a007dd2015-06-11 16:22:34 -07004 * Permission is hereby granted, free of charge, to any person obtaining
5 * a copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sublicense, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
Kristian Høgsberg380deee2012-05-21 17:12:41 -040011 *
Bryce Harrington0a007dd2015-06-11 16:22:34 -070012 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial
14 * portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
20 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
21 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
Kristian Høgsberg380deee2012-05-21 17:12:41 -040024 */
25
Daniel Stonec228e232013-05-22 18:03:19 +030026#include "config.h"
Kristian Høgsberg380deee2012-05-21 17:12:41 -040027
28#include <stdlib.h>
Jussi Kukkonen649bbce2016-07-19 14:16:27 +030029#include <stdint.h>
Kristian Høgsberg380deee2012-05-21 17:12:41 -040030#include <stdio.h>
31#include <string.h>
32#include <sys/socket.h>
33#include <sys/un.h>
34#include <fcntl.h>
35#include <errno.h>
36#include <unistd.h>
37#include <signal.h>
Pekka Paalanen505237e2016-12-01 15:41:11 +020038#include <assert.h>
Tiago Vignatti90fada42012-07-16 12:02:08 -040039#include <X11/Xcursor/Xcursor.h>
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -050040#include <linux/input.h>
Kristian Høgsberg380deee2012-05-21 17:12:41 -040041
Daniel Stone67fe3db2016-10-31 14:51:18 +000042#include "compositor.h"
Kristian Høgsberg380deee2012-05-21 17:12:41 -040043#include "xwayland.h"
Quentin Glidic955cec02016-08-12 10:41:35 +020044#include "xwayland-internal-interface.h"
Kristian Høgsberg380deee2012-05-21 17:12:41 -040045
Kristian Høgsberg2ba10df2013-12-03 16:38:15 -080046#include "cairo-util.h"
Kristian Høgsberg380deee2012-05-21 17:12:41 -040047#include "hash.h"
Jon Cruz35b2eaa2015-06-15 15:37:08 -070048#include "shared/helpers.h"
Kristian Høgsberg380deee2012-05-21 17:12:41 -040049
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -070050struct wm_size_hints {
Bryce Harringtone00554b2015-06-12 10:17:39 -070051 uint32_t flags;
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -070052 int32_t x, y;
53 int32_t width, height; /* should set so old wm's don't mess up */
54 int32_t min_width, min_height;
55 int32_t max_width, max_height;
Bryce Harringtone00554b2015-06-12 10:17:39 -070056 int32_t width_inc, height_inc;
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -070057 struct {
58 int32_t x;
59 int32_t y;
60 } min_aspect, max_aspect;
61 int32_t base_width, base_height;
62 int32_t win_gravity;
63};
64
65#define USPosition (1L << 0)
66#define USSize (1L << 1)
67#define PPosition (1L << 2)
68#define PSize (1L << 3)
69#define PMinSize (1L << 4)
70#define PMaxSize (1L << 5)
71#define PResizeInc (1L << 6)
72#define PAspect (1L << 7)
73#define PBaseSize (1L << 8)
74#define PWinGravity (1L << 9)
75
Kristian Høgsberg380deee2012-05-21 17:12:41 -040076struct motif_wm_hints {
77 uint32_t flags;
78 uint32_t functions;
79 uint32_t decorations;
80 int32_t input_mode;
81 uint32_t status;
82};
83
84#define MWM_HINTS_FUNCTIONS (1L << 0)
85#define MWM_HINTS_DECORATIONS (1L << 1)
86#define MWM_HINTS_INPUT_MODE (1L << 2)
87#define MWM_HINTS_STATUS (1L << 3)
88
89#define MWM_FUNC_ALL (1L << 0)
90#define MWM_FUNC_RESIZE (1L << 1)
91#define MWM_FUNC_MOVE (1L << 2)
92#define MWM_FUNC_MINIMIZE (1L << 3)
93#define MWM_FUNC_MAXIMIZE (1L << 4)
94#define MWM_FUNC_CLOSE (1L << 5)
95
96#define MWM_DECOR_ALL (1L << 0)
97#define MWM_DECOR_BORDER (1L << 1)
98#define MWM_DECOR_RESIZEH (1L << 2)
99#define MWM_DECOR_TITLE (1L << 3)
100#define MWM_DECOR_MENU (1L << 4)
101#define MWM_DECOR_MINIMIZE (1L << 5)
102#define MWM_DECOR_MAXIMIZE (1L << 6)
103
Dima Ryazanovb0f5a252015-05-03 19:56:37 -0700104#define MWM_DECOR_EVERYTHING \
105 (MWM_DECOR_BORDER | MWM_DECOR_RESIZEH | MWM_DECOR_TITLE | \
106 MWM_DECOR_MENU | MWM_DECOR_MINIMIZE | MWM_DECOR_MAXIMIZE)
107
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400108#define MWM_INPUT_MODELESS 0
109#define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1
110#define MWM_INPUT_SYSTEM_MODAL 2
111#define MWM_INPUT_FULL_APPLICATION_MODAL 3
112#define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL
113
114#define MWM_TEAROFF_WINDOW (1L<<0)
115
116#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT 0
117#define _NET_WM_MOVERESIZE_SIZE_TOP 1
118#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT 2
119#define _NET_WM_MOVERESIZE_SIZE_RIGHT 3
120#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT 4
121#define _NET_WM_MOVERESIZE_SIZE_BOTTOM 5
122#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT 6
123#define _NET_WM_MOVERESIZE_SIZE_LEFT 7
124#define _NET_WM_MOVERESIZE_MOVE 8 /* movement only */
125#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD 9 /* size via keyboard */
126#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD 10 /* move via keyboard */
127#define _NET_WM_MOVERESIZE_CANCEL 11 /* cancel operation */
128
Pekka Paalanen505237e2016-12-01 15:41:11 +0200129struct weston_output_weak_ref {
130 struct weston_output *output;
131 struct wl_listener destroy_listener;
132};
133
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400134struct weston_wm_window {
135 struct weston_wm *wm;
136 xcb_window_t id;
137 xcb_window_t frame_id;
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500138 struct frame *frame;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400139 cairo_surface_t *cairo_surface;
Kristian Høgsberg757d8af2014-03-17 22:33:29 -0700140 uint32_t surface_id;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400141 struct weston_surface *surface;
Quentin Glidic955cec02016-08-12 10:41:35 +0200142 struct weston_desktop_xwayland_surface *shsurf;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400143 struct wl_listener surface_destroy_listener;
144 struct wl_event_source *repaint_source;
Kristian Høgsberga61ca062012-05-22 16:05:52 -0400145 struct wl_event_source *configure_source;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400146 int properties_dirty;
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +0300147 int pid;
148 char *machine;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400149 char *class;
150 char *name;
151 struct weston_wm_window *transient_for;
152 uint32_t protocols;
153 xcb_atom_t type;
154 int width, height;
155 int x, y;
Giulio Camuffof05d18f2015-12-11 20:57:05 +0200156 bool pos_dirty;
Pekka Paalanen505237e2016-12-01 15:41:11 +0200157 struct weston_output_weak_ref legacy_fullscreen_output;
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500158 int saved_width, saved_height;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400159 int decorate;
Tiago Vignatti771241e2012-06-04 20:01:45 +0300160 int override_redirect;
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500161 int fullscreen;
MoD384a11a2013-06-22 11:04:21 -0500162 int has_alpha;
Kristian Høgsberg2cd6da12013-10-13 22:11:07 -0700163 int delete_window;
Giulio Camuffo6b4b2412015-01-29 19:06:49 +0200164 int maximized_vert;
165 int maximized_horz;
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -0700166 struct wm_size_hints size_hints;
167 struct motif_wm_hints motif_hints;
Kristian Høgsberg757d8af2014-03-17 22:33:29 -0700168 struct wl_list link;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400169};
170
171static struct weston_wm_window *
172get_wm_window(struct weston_surface *surface);
173
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400174static void
Benoit Gschwind1a42ca12015-09-25 21:26:04 +0200175weston_wm_set_net_active_window(struct weston_wm *wm, xcb_window_t window);
176
177static void
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400178weston_wm_window_schedule_repaint(struct weston_wm_window *window);
179
Pekka Paalanen505237e2016-12-01 15:41:11 +0200180static int
181legacy_fullscreen(struct weston_wm *wm,
182 struct weston_wm_window *window,
183 struct weston_output **output_ret);
184
Kristian Høgsberg757d8af2014-03-17 22:33:29 -0700185static void
186xserver_map_shell_surface(struct weston_wm_window *window,
187 struct weston_surface *surface);
188
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400189static int __attribute__ ((format (printf, 1, 2)))
190wm_log(const char *fmt, ...)
191{
192#ifdef WM_DEBUG
193 int l;
194 va_list argp;
195
196 va_start(argp, fmt);
197 l = weston_vlog(fmt, argp);
198 va_end(argp);
199
200 return l;
201#else
202 return 0;
203#endif
204}
205
206static int __attribute__ ((format (printf, 1, 2)))
207wm_log_continue(const char *fmt, ...)
208{
209#ifdef WM_DEBUG
210 int l;
211 va_list argp;
212
213 va_start(argp, fmt);
214 l = weston_vlog_continue(fmt, argp);
215 va_end(argp);
216
217 return l;
218#else
219 return 0;
220#endif
221}
222
Pekka Paalanen505237e2016-12-01 15:41:11 +0200223static void
224weston_output_weak_ref_init(struct weston_output_weak_ref *ref)
225{
226 ref->output = NULL;
227}
228
229static void
230weston_output_weak_ref_clear(struct weston_output_weak_ref *ref)
231{
232 if (!ref->output)
233 return;
234
235 wl_list_remove(&ref->destroy_listener.link);
236 ref->output = NULL;
237}
238
239static void
240weston_output_weak_ref_handle_destroy(struct wl_listener *listener, void *data)
241{
242 struct weston_output_weak_ref *ref;
243
244 ref = wl_container_of(listener, ref, destroy_listener);
245 assert(ref->output == data);
246
247 weston_output_weak_ref_clear(ref);
248}
249
250static void
251weston_output_weak_ref_set(struct weston_output_weak_ref *ref,
252 struct weston_output *output)
253{
254 weston_output_weak_ref_clear(ref);
255
256 if (!output)
257 return;
258
259 ref->destroy_listener.notify = weston_output_weak_ref_handle_destroy;
260 wl_signal_add(&output->destroy_signal, &ref->destroy_listener);
261 ref->output = output;
262}
263
Derek Foreman49372142015-04-09 10:51:22 -0500264static bool __attribute__ ((warn_unused_result))
265wm_lookup_window(struct weston_wm *wm, xcb_window_t hash,
266 struct weston_wm_window **window)
267{
268 *window = hash_table_lookup(wm->window_hash, hash);
269 if (*window)
270 return true;
271 return false;
272}
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400273
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400274const char *
275get_atom_name(xcb_connection_t *c, xcb_atom_t atom)
276{
277 xcb_get_atom_name_cookie_t cookie;
278 xcb_get_atom_name_reply_t *reply;
279 xcb_generic_error_t *e;
280 static char buffer[64];
281
282 if (atom == XCB_ATOM_NONE)
283 return "None";
284
285 cookie = xcb_get_atom_name (c, atom);
286 reply = xcb_get_atom_name_reply (c, cookie, &e);
MoD55375b92013-06-11 19:59:42 -0500287
Dawid Gajownik74a635b2015-08-06 17:12:19 -0300288 if (reply) {
MoD55375b92013-06-11 19:59:42 -0500289 snprintf(buffer, sizeof buffer, "%.*s",
290 xcb_get_atom_name_name_length (reply),
291 xcb_get_atom_name_name (reply));
292 } else {
293 snprintf(buffer, sizeof buffer, "(atom %u)", atom);
294 }
295
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400296 free(reply);
297
298 return buffer;
299}
300
Tiago Vignatti90fada42012-07-16 12:02:08 -0400301static xcb_cursor_t
302xcb_cursor_image_load_cursor(struct weston_wm *wm, const XcursorImage *img)
303{
304 xcb_connection_t *c = wm->conn;
305 xcb_screen_iterator_t s = xcb_setup_roots_iterator(xcb_get_setup(c));
306 xcb_screen_t *screen = s.data;
307 xcb_gcontext_t gc;
308 xcb_pixmap_t pix;
309 xcb_render_picture_t pic;
310 xcb_cursor_t cursor;
311 int stride = img->width * 4;
312
313 pix = xcb_generate_id(c);
314 xcb_create_pixmap(c, 32, pix, screen->root, img->width, img->height);
315
316 pic = xcb_generate_id(c);
317 xcb_render_create_picture(c, pic, pix, wm->format_rgba.id, 0, 0);
318
319 gc = xcb_generate_id(c);
320 xcb_create_gc(c, gc, pix, 0, 0);
321
322 xcb_put_image(c, XCB_IMAGE_FORMAT_Z_PIXMAP, pix, gc,
323 img->width, img->height, 0, 0, 0, 32,
324 stride * img->height, (uint8_t *) img->pixels);
325 xcb_free_gc(c, gc);
326
327 cursor = xcb_generate_id(c);
328 xcb_render_create_cursor(c, cursor, pic, img->xhot, img->yhot);
329
330 xcb_render_free_picture(c, pic);
331 xcb_free_pixmap(c, pix);
332
333 return cursor;
334}
335
336static xcb_cursor_t
337xcb_cursor_images_load_cursor(struct weston_wm *wm, const XcursorImages *images)
338{
339 /* TODO: treat animated cursors as well */
340 if (images->nimage != 1)
341 return -1;
342
343 return xcb_cursor_image_load_cursor(wm, images->images[0]);
344}
345
346static xcb_cursor_t
347xcb_cursor_library_load_cursor(struct weston_wm *wm, const char *file)
348{
349 xcb_cursor_t cursor;
350 XcursorImages *images;
351 char *v = NULL;
352 int size = 0;
353
354 if (!file)
355 return 0;
356
357 v = getenv ("XCURSOR_SIZE");
358 if (v)
359 size = atoi(v);
360
361 if (!size)
362 size = 32;
363
364 images = XcursorLibraryLoadImages (file, NULL, size);
Tiago Vignattiac78bb12012-09-28 16:29:46 +0300365 if (!images)
366 return -1;
367
Tiago Vignatti90fada42012-07-16 12:02:08 -0400368 cursor = xcb_cursor_images_load_cursor (wm, images);
369 XcursorImagesDestroy (images);
370
371 return cursor;
372}
373
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400374void
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400375dump_property(struct weston_wm *wm,
376 xcb_atom_t property, xcb_get_property_reply_t *reply)
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400377{
378 int32_t *incr_value;
379 const char *text_value, *name;
380 xcb_atom_t *atom_value;
381 int width, len;
382 uint32_t i;
383
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400384 width = wm_log_continue("%s: ", get_atom_name(wm->conn, property));
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400385 if (reply == NULL) {
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400386 wm_log_continue("(no reply)\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400387 return;
388 }
389
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400390 width += wm_log_continue("%s/%d, length %d (value_len %d): ",
391 get_atom_name(wm->conn, reply->type),
392 reply->format,
393 xcb_get_property_value_length(reply),
394 reply->value_len);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400395
396 if (reply->type == wm->atom.incr) {
397 incr_value = xcb_get_property_value(reply);
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400398 wm_log_continue("%d\n", *incr_value);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400399 } else if (reply->type == wm->atom.utf8_string ||
400 reply->type == wm->atom.string) {
401 text_value = xcb_get_property_value(reply);
402 if (reply->value_len > 40)
403 len = 40;
404 else
405 len = reply->value_len;
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400406 wm_log_continue("\"%.*s\"\n", len, text_value);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400407 } else if (reply->type == XCB_ATOM_ATOM) {
408 atom_value = xcb_get_property_value(reply);
409 for (i = 0; i < reply->value_len; i++) {
410 name = get_atom_name(wm->conn, atom_value[i]);
411 if (width + strlen(name) + 2 > 78) {
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400412 wm_log_continue("\n ");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400413 width = 4;
414 } else if (i > 0) {
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400415 width += wm_log_continue(", ");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400416 }
417
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400418 width += wm_log_continue("%s", name);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400419 }
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400420 wm_log_continue("\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400421 } else {
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400422 wm_log_continue("huh?\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400423 }
424}
425
Tiago Vignatti2d129f12012-11-30 17:19:59 -0200426static void
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400427read_and_dump_property(struct weston_wm *wm,
428 xcb_window_t window, xcb_atom_t property)
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400429{
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400430 xcb_get_property_reply_t *reply;
431 xcb_get_property_cookie_t cookie;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400432
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400433 cookie = xcb_get_property(wm->conn, 0, window,
434 property, XCB_ATOM_ANY, 0, 2048);
435 reply = xcb_get_property_reply(wm->conn, cookie, NULL);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400436
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400437 dump_property(wm, property, reply);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400438
Kristian Høgsberg0273b572012-05-30 09:58:02 -0400439 free(reply);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400440}
441
Pekka Paalanen20111d52016-12-01 17:07:12 +0200442/* We reuse some predefined, but otherwise useles atoms
443 * as local type placeholders that never touch the X11 server,
444 * to make weston_wm_window_read_properties() less exceptional.
445 */
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400446#define TYPE_WM_PROTOCOLS XCB_ATOM_CUT_BUFFER0
447#define TYPE_MOTIF_WM_HINTS XCB_ATOM_CUT_BUFFER1
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500448#define TYPE_NET_WM_STATE XCB_ATOM_CUT_BUFFER2
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -0700449#define TYPE_WM_NORMAL_HINTS XCB_ATOM_CUT_BUFFER3
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400450
451static void
452weston_wm_window_read_properties(struct weston_wm_window *window)
453{
454 struct weston_wm *wm = window->wm;
455
Pekka Paalanen20111d52016-12-01 17:07:12 +0200456#define F(field) (&window->field)
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400457 const struct {
458 xcb_atom_t atom;
459 xcb_atom_t type;
Pekka Paalanen20111d52016-12-01 17:07:12 +0200460 void *ptr;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400461 } props[] = {
Pekka Paalanen20111d52016-12-01 17:07:12 +0200462 { XCB_ATOM_WM_CLASS, XCB_ATOM_STRING, F(class) },
463 { XCB_ATOM_WM_NAME, XCB_ATOM_STRING, F(name) },
464 { XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, F(transient_for) },
465 { wm->atom.wm_protocols, TYPE_WM_PROTOCOLS, NULL },
466 { wm->atom.wm_normal_hints, TYPE_WM_NORMAL_HINTS, NULL },
467 { wm->atom.net_wm_state, TYPE_NET_WM_STATE, NULL },
468 { wm->atom.net_wm_window_type, XCB_ATOM_ATOM, F(type) },
469 { wm->atom.net_wm_name, XCB_ATOM_STRING, F(name) },
470 { wm->atom.net_wm_pid, XCB_ATOM_CARDINAL, F(pid) },
471 { wm->atom.motif_wm_hints, TYPE_MOTIF_WM_HINTS, NULL },
472 { wm->atom.wm_client_machine, XCB_ATOM_WM_CLIENT_MACHINE, F(machine) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400473 };
474#undef F
475
476 xcb_get_property_cookie_t cookie[ARRAY_LENGTH(props)];
477 xcb_get_property_reply_t *reply;
478 void *p;
479 uint32_t *xid;
480 xcb_atom_t *atom;
481 uint32_t i;
Giulio Camuffoa8e9b412015-01-27 19:10:37 +0200482 char name[1024];
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400483
484 if (!window->properties_dirty)
485 return;
486 window->properties_dirty = 0;
487
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400488 for (i = 0; i < ARRAY_LENGTH(props); i++)
489 cookie[i] = xcb_get_property(wm->conn,
490 0, /* delete */
491 window->id,
492 props[i].atom,
493 XCB_ATOM_ANY, 0, 2048);
494
Dima Ryazanovb0f5a252015-05-03 19:56:37 -0700495 window->decorate = window->override_redirect ? 0 : MWM_DECOR_EVERYTHING;
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -0700496 window->size_hints.flags = 0;
497 window->motif_hints.flags = 0;
Kristian Høgsberg2cd6da12013-10-13 22:11:07 -0700498 window->delete_window = 0;
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -0700499
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400500 for (i = 0; i < ARRAY_LENGTH(props); i++) {
501 reply = xcb_get_property_reply(wm->conn, cookie[i], NULL);
502 if (!reply)
503 /* Bad window, typically */
504 continue;
505 if (reply->type == XCB_ATOM_NONE) {
506 /* No such property */
507 free(reply);
508 continue;
509 }
510
Pekka Paalanen20111d52016-12-01 17:07:12 +0200511 p = props[i].ptr;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400512
513 switch (props[i].type) {
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +0300514 case XCB_ATOM_WM_CLIENT_MACHINE:
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400515 case XCB_ATOM_STRING:
516 /* FIXME: We're using this for both string and
517 utf8_string */
518 if (*(char **) p)
519 free(*(char **) p);
520
521 *(char **) p =
522 strndup(xcb_get_property_value(reply),
523 xcb_get_property_value_length(reply));
524 break;
525 case XCB_ATOM_WINDOW:
526 xid = xcb_get_property_value(reply);
Derek Foreman49372142015-04-09 10:51:22 -0500527 if (!wm_lookup_window(wm, *xid, p))
528 weston_log("XCB_ATOM_WINDOW contains window"
529 " id not found in hash table.\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400530 break;
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +0300531 case XCB_ATOM_CARDINAL:
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400532 case XCB_ATOM_ATOM:
533 atom = xcb_get_property_value(reply);
534 *(xcb_atom_t *) p = *atom;
535 break;
536 case TYPE_WM_PROTOCOLS:
Kristian Høgsberg2cd6da12013-10-13 22:11:07 -0700537 atom = xcb_get_property_value(reply);
538 for (i = 0; i < reply->value_len; i++)
Derek Foremanb4deec62015-04-07 12:12:13 -0500539 if (atom[i] == wm->atom.wm_delete_window) {
Kristian Høgsberg2cd6da12013-10-13 22:11:07 -0700540 window->delete_window = 1;
Derek Foremanb4deec62015-04-07 12:12:13 -0500541 break;
542 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400543 break;
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -0700544 case TYPE_WM_NORMAL_HINTS:
545 memcpy(&window->size_hints,
546 xcb_get_property_value(reply),
547 sizeof window->size_hints);
548 break;
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500549 case TYPE_NET_WM_STATE:
550 window->fullscreen = 0;
551 atom = xcb_get_property_value(reply);
Ryo Munakataf3744f52015-03-11 17:36:30 +0900552 for (i = 0; i < reply->value_len; i++) {
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500553 if (atom[i] == wm->atom.net_wm_state_fullscreen)
554 window->fullscreen = 1;
Giulio Camuffo6b4b2412015-01-29 19:06:49 +0200555 if (atom[i] == wm->atom.net_wm_state_maximized_vert)
556 window->maximized_vert = 1;
557 if (atom[i] == wm->atom.net_wm_state_maximized_horz)
558 window->maximized_horz = 1;
Ryo Munakataf3744f52015-03-11 17:36:30 +0900559 }
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500560 break;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400561 case TYPE_MOTIF_WM_HINTS:
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -0700562 memcpy(&window->motif_hints,
563 xcb_get_property_value(reply),
564 sizeof window->motif_hints);
Dima Ryazanovb0f5a252015-05-03 19:56:37 -0700565 if (window->motif_hints.flags & MWM_HINTS_DECORATIONS) {
566 if (window->motif_hints.decorations & MWM_DECOR_ALL)
567 /* MWM_DECOR_ALL means all except the other values listed. */
568 window->decorate =
569 MWM_DECOR_EVERYTHING & (~window->motif_hints.decorations);
570 else
571 window->decorate =
572 window->motif_hints.decorations;
573 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400574 break;
575 default:
576 break;
577 }
578 free(reply);
579 }
Giulio Camuffo62942ad2013-09-11 18:20:47 +0200580
Giulio Camuffoa8e9b412015-01-27 19:10:37 +0200581 if (window->pid > 0) {
582 gethostname(name, sizeof(name));
583 for (i = 0; i < sizeof(name); i++) {
584 if (name[i] == '\0')
585 break;
586 }
587 if (i == sizeof(name))
588 name[0] = '\0'; /* ignore stupid hostnames */
589
590 /* this is only one heuristic to guess the PID of a client is
591 * valid, assuming it's compliant with icccm and ewmh.
592 * Non-compliants and remote applications of course fail. */
593 if (!window->machine || strcmp(window->machine, name))
594 window->pid = 0;
595 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400596}
597
Pekka Paalanen20111d52016-12-01 17:07:12 +0200598#undef TYPE_WM_PROTOCOLS
599#undef TYPE_MOTIF_WM_HINTS
600#undef TYPE_NET_WM_STATE
601#undef TYPE_WM_NORMAL_HINTS
602
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400603static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400604weston_wm_window_get_frame_size(struct weston_wm_window *window,
605 int *width, int *height)
606{
607 struct theme *t = window->wm->theme;
608
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500609 if (window->fullscreen) {
610 *width = window->width;
611 *height = window->height;
Dima Ryazanovcae1f0f2013-11-15 02:02:23 -0800612 } else if (window->decorate && window->frame) {
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500613 *width = frame_width(window->frame);
614 *height = frame_height(window->frame);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400615 } else {
616 *width = window->width + t->margin * 2;
617 *height = window->height + t->margin * 2;
618 }
619}
620
621static void
622weston_wm_window_get_child_position(struct weston_wm_window *window,
623 int *x, int *y)
624{
625 struct theme *t = window->wm->theme;
626
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500627 if (window->fullscreen) {
628 *x = 0;
629 *y = 0;
Dima Ryazanovcae1f0f2013-11-15 02:02:23 -0800630 } else if (window->decorate && window->frame) {
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500631 frame_interior(window->frame, x, y, NULL, NULL);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400632 } else {
633 *x = t->margin;
634 *y = t->margin;
635 }
636}
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400637
638static void
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500639weston_wm_window_send_configure_notify(struct weston_wm_window *window)
640{
641 xcb_configure_notify_event_t configure_notify;
642 struct weston_wm *wm = window->wm;
643 int x, y;
644
645 weston_wm_window_get_child_position(window, &x, &y);
646 configure_notify.response_type = XCB_CONFIGURE_NOTIFY;
647 configure_notify.pad0 = 0;
648 configure_notify.event = window->id;
649 configure_notify.window = window->id;
650 configure_notify.above_sibling = XCB_WINDOW_NONE;
651 configure_notify.x = x;
652 configure_notify.y = y;
653 configure_notify.width = window->width;
654 configure_notify.height = window->height;
655 configure_notify.border_width = 0;
656 configure_notify.override_redirect = 0;
657 configure_notify.pad1 = 0;
658
Murray Calavera883ac022015-06-06 13:02:22 +0000659 xcb_send_event(wm->conn, 0, window->id,
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500660 XCB_EVENT_MASK_STRUCTURE_NOTIFY,
661 (char *) &configure_notify);
662}
663
664static void
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400665weston_wm_handle_configure_request(struct weston_wm *wm, xcb_generic_event_t *event)
666{
Murray Calavera883ac022015-06-06 13:02:22 +0000667 xcb_configure_request_event_t *configure_request =
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400668 (xcb_configure_request_event_t *) event;
669 struct weston_wm_window *window;
670 uint32_t mask, values[16];
671 int x, y, width, height, i = 0;
672
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400673 wm_log("XCB_CONFIGURE_REQUEST (window %d) %d,%d @ %dx%d\n",
674 configure_request->window,
675 configure_request->x, configure_request->y,
676 configure_request->width, configure_request->height);
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400677
Derek Foreman49372142015-04-09 10:51:22 -0500678 if (!wm_lookup_window(wm, configure_request->window, &window))
679 return;
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400680
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500681 if (window->fullscreen) {
682 weston_wm_window_send_configure_notify(window);
683 return;
684 }
685
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400686 if (configure_request->value_mask & XCB_CONFIG_WINDOW_WIDTH)
687 window->width = configure_request->width;
688 if (configure_request->value_mask & XCB_CONFIG_WINDOW_HEIGHT)
689 window->height = configure_request->height;
690
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500691 if (window->frame)
692 frame_resize_inside(window->frame, window->width, window->height);
693
Kristian Høgsbergeaee7842012-05-22 10:04:20 -0400694 weston_wm_window_get_child_position(window, &x, &y);
695 values[i++] = x;
696 values[i++] = y;
697 values[i++] = window->width;
698 values[i++] = window->height;
699 values[i++] = 0;
700 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
701 XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
702 XCB_CONFIG_WINDOW_BORDER_WIDTH;
703 if (configure_request->value_mask & XCB_CONFIG_WINDOW_SIBLING) {
704 values[i++] = configure_request->sibling;
705 mask |= XCB_CONFIG_WINDOW_SIBLING;
706 }
707 if (configure_request->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
708 values[i++] = configure_request->stack_mode;
709 mask |= XCB_CONFIG_WINDOW_STACK_MODE;
710 }
711
712 xcb_configure_window(wm->conn, window->id, mask, values);
713
714 weston_wm_window_get_frame_size(window, &width, &height);
715 values[0] = width;
716 values[1] = height;
717 mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
718 xcb_configure_window(wm->conn, window->frame_id, mask, values);
719
720 weston_wm_window_schedule_repaint(window);
721}
722
Kristian Høgsberg00db2ee2013-07-04 02:29:32 -0400723static int
724our_resource(struct weston_wm *wm, uint32_t id)
725{
726 const xcb_setup_t *setup;
727
728 setup = xcb_get_setup(wm->conn);
729
730 return (id & ~setup->resource_id_mask) == setup->resource_id_base;
731}
732
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400733static void
734weston_wm_handle_configure_notify(struct weston_wm *wm, xcb_generic_event_t *event)
735{
Murray Calavera883ac022015-06-06 13:02:22 +0000736 xcb_configure_notify_event_t *configure_notify =
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400737 (xcb_configure_notify_event_t *) event;
738 struct weston_wm_window *window;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400739
Pekka Paalanen73428a82016-12-19 15:10:01 +0200740 wm_log("XCB_CONFIGURE_NOTIFY (window %d) %d,%d @ %dx%d%s\n",
Kristian Høgsberg082d58c2013-06-18 01:00:27 -0400741 configure_notify->window,
742 configure_notify->x, configure_notify->y,
Pekka Paalanen73428a82016-12-19 15:10:01 +0200743 configure_notify->width, configure_notify->height,
744 configure_notify->override_redirect ? ", override" : "");
Tiago Vignattie66fcee2012-07-20 23:09:54 +0300745
Derek Foreman49372142015-04-09 10:51:22 -0500746 if (!wm_lookup_window(wm, configure_notify->window, &window))
747 return;
748
Kristian Høgsberg122877d2013-08-22 16:18:17 -0700749 window->x = configure_notify->x;
750 window->y = configure_notify->y;
Giulio Camuffof05d18f2015-12-11 20:57:05 +0200751 window->pos_dirty = false;
752
Kristian Høgsberg1b6fed42013-08-31 00:00:57 -0700753 if (window->override_redirect) {
754 window->width = configure_notify->width;
755 window->height = configure_notify->height;
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500756 if (window->frame)
757 frame_resize_inside(window->frame,
758 window->width, window->height);
Kristian Høgsberg1b6fed42013-08-31 00:00:57 -0700759 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400760}
761
762static void
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +0300763weston_wm_kill_client(struct wl_listener *listener, void *data)
764{
765 struct weston_surface *surface = data;
766 struct weston_wm_window *window = get_wm_window(surface);
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +0300767 if (!window)
768 return;
769
Giulio Camuffoa8e9b412015-01-27 19:10:37 +0200770 if (window->pid > 0)
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +0300771 kill(window->pid, SIGKILL);
772}
773
774static void
Kristian Høgsberg757d8af2014-03-17 22:33:29 -0700775weston_wm_create_surface(struct wl_listener *listener, void *data)
776{
777 struct weston_surface *surface = data;
778 struct weston_wm *wm =
779 container_of(listener,
780 struct weston_wm, create_surface_listener);
781 struct weston_wm_window *window;
782
783 if (wl_resource_get_client(surface->resource) != wm->server->client)
784 return;
785
786 wl_list_for_each(window, &wm->unpaired_window_list, link)
787 if (window->surface_id ==
788 wl_resource_get_id(surface->resource)) {
789 xserver_map_shell_surface(window, surface);
Kristian Høgsbergba83db22014-04-07 10:16:19 -0700790 window->surface_id = 0;
791 wl_list_remove(&window->link);
Kristian Høgsberg757d8af2014-03-17 22:33:29 -0700792 break;
Murray Calavera883ac022015-06-06 13:02:22 +0000793 }
Kristian Høgsberg757d8af2014-03-17 22:33:29 -0700794}
795
796static void
Giulio Camuffob18f7882015-03-29 14:20:23 +0300797weston_wm_send_focus_window(struct weston_wm *wm,
798 struct weston_wm_window *window)
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400799{
Scott Moreau85ecac02012-05-21 15:49:14 -0600800 xcb_client_message_event_t client_message;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400801
Scott Moreau85ecac02012-05-21 15:49:14 -0600802 if (window) {
Jasper St. Pierref30af4e2015-03-22 10:14:49 -0700803 uint32_t values[1];
804
Boyan Dingb9f863c2014-08-30 10:33:23 +0800805 if (window->override_redirect)
806 return;
807
Scott Moreau85ecac02012-05-21 15:49:14 -0600808 client_message.response_type = XCB_CLIENT_MESSAGE;
809 client_message.format = 32;
810 client_message.window = window->id;
811 client_message.type = wm->atom.wm_protocols;
812 client_message.data.data32[0] = wm->atom.wm_take_focus;
813 client_message.data.data32[1] = XCB_TIME_CURRENT_TIME;
814
Murray Calavera883ac022015-06-06 13:02:22 +0000815 xcb_send_event(wm->conn, 0, window->id,
Scott Moreau85ecac02012-05-21 15:49:14 -0600816 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
817 (char *) &client_message);
818
819 xcb_set_input_focus (wm->conn, XCB_INPUT_FOCUS_POINTER_ROOT,
820 window->id, XCB_TIME_CURRENT_TIME);
Jasper St. Pierref30af4e2015-03-22 10:14:49 -0700821
822 values[0] = XCB_STACK_MODE_ABOVE;
823 xcb_configure_window (wm->conn, window->frame_id,
824 XCB_CONFIG_WINDOW_STACK_MODE, values);
Scott Moreau85ecac02012-05-21 15:49:14 -0600825 } else {
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400826 xcb_set_input_focus (wm->conn,
827 XCB_INPUT_FOCUS_POINTER_ROOT,
828 XCB_NONE,
829 XCB_TIME_CURRENT_TIME);
Scott Moreau85ecac02012-05-21 15:49:14 -0600830 }
Giulio Camuffob18f7882015-03-29 14:20:23 +0300831}
832
833static void
834weston_wm_window_activate(struct wl_listener *listener, void *data)
835{
Jonas Ådahlf7deb6a2016-07-22 17:50:26 +0800836 struct weston_surface_activation_data *activation_data = data;
837 struct weston_surface *surface = activation_data->surface;
Giulio Camuffob18f7882015-03-29 14:20:23 +0300838 struct weston_wm_window *window = NULL;
839 struct weston_wm *wm =
840 container_of(listener, struct weston_wm, activate_listener);
841
842 if (surface) {
843 window = get_wm_window(surface);
844 }
845
Benoit Gschwind1a42ca12015-09-25 21:26:04 +0200846 if (window) {
847 weston_wm_set_net_active_window(wm, window->id);
848 } else {
849 weston_wm_set_net_active_window(wm, XCB_WINDOW_NONE);
850 }
851
Giulio Camuffob18f7882015-03-29 14:20:23 +0300852 weston_wm_send_focus_window(wm, window);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400853
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500854 if (wm->focus_window) {
Dima Ryazanovb03b87f2013-11-15 02:01:19 -0800855 if (wm->focus_window->frame)
856 frame_unset_flag(wm->focus_window->frame, FRAME_FLAG_ACTIVE);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400857 weston_wm_window_schedule_repaint(wm->focus_window);
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500858 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400859 wm->focus_window = window;
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500860 if (wm->focus_window) {
Dima Ryazanovb03b87f2013-11-15 02:01:19 -0800861 if (wm->focus_window->frame)
862 frame_set_flag(wm->focus_window->frame, FRAME_FLAG_ACTIVE);
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400863 weston_wm_window_schedule_repaint(wm->focus_window);
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500864 }
Benoit Gschwind1a42ca12015-09-25 21:26:04 +0200865
866 xcb_flush(wm->conn);
867
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400868}
869
Kristian Høgsberga6d9a5e2012-05-30 12:15:44 -0400870#define ICCCM_WITHDRAWN_STATE 0
871#define ICCCM_NORMAL_STATE 1
872#define ICCCM_ICONIC_STATE 3
873
874static void
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500875weston_wm_window_set_wm_state(struct weston_wm_window *window, int32_t state)
Kristian Høgsberga6d9a5e2012-05-30 12:15:44 -0400876{
877 struct weston_wm *wm = window->wm;
878 uint32_t property[2];
879
880 property[0] = state;
881 property[1] = XCB_WINDOW_NONE;
882
883 xcb_change_property(wm->conn,
884 XCB_PROP_MODE_REPLACE,
885 window->id,
886 wm->atom.wm_state,
887 wm->atom.wm_state,
888 32, /* format */
889 2, property);
890}
891
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400892static void
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500893weston_wm_window_set_net_wm_state(struct weston_wm_window *window)
894{
895 struct weston_wm *wm = window->wm;
Giulio Camuffo6b4b2412015-01-29 19:06:49 +0200896 uint32_t property[3];
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500897 int i;
898
899 i = 0;
900 if (window->fullscreen)
901 property[i++] = wm->atom.net_wm_state_fullscreen;
Giulio Camuffo6b4b2412015-01-29 19:06:49 +0200902 if (window->maximized_vert)
903 property[i++] = wm->atom.net_wm_state_maximized_vert;
904 if (window->maximized_horz)
905 property[i++] = wm->atom.net_wm_state_maximized_horz;
Kristian Høgsbergb810eb52013-02-12 20:07:05 -0500906
907 xcb_change_property(wm->conn,
908 XCB_PROP_MODE_REPLACE,
909 window->id,
910 wm->atom.net_wm_state,
911 XCB_ATOM_ATOM,
912 32, /* format */
913 i, property);
914}
915
916static void
Kristian Høgsberg318ea372013-09-03 16:19:18 -0700917weston_wm_window_create_frame(struct weston_wm_window *window)
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400918{
Kristian Høgsberg318ea372013-09-03 16:19:18 -0700919 struct weston_wm *wm = window->wm;
Kristian Høgsbergf9187192013-05-02 13:43:24 -0400920 uint32_t values[3];
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400921 int x, y, width, height;
Giulio Camuffo6b4b2412015-01-29 19:06:49 +0200922 int buttons = FRAME_BUTTON_CLOSE;
923
924 if (window->decorate & MWM_DECOR_MAXIMIZE)
925 buttons |= FRAME_BUTTON_MAXIMIZE;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400926
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500927 window->frame = frame_create(window->wm->theme,
928 window->width, window->height,
Giulio Camuffo6b4b2412015-01-29 19:06:49 +0200929 buttons, window->name);
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -0500930 frame_resize_inside(window->frame, window->width, window->height);
931
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400932 weston_wm_window_get_frame_size(window, &width, &height);
933 weston_wm_window_get_child_position(window, &x, &y);
934
Kristian Høgsbergf9187192013-05-02 13:43:24 -0400935 values[0] = wm->screen->black_pixel;
936 values[1] =
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400937 XCB_EVENT_MASK_KEY_PRESS |
938 XCB_EVENT_MASK_KEY_RELEASE |
939 XCB_EVENT_MASK_BUTTON_PRESS |
940 XCB_EVENT_MASK_BUTTON_RELEASE |
Tiago Vignatti236b48d2012-07-16 12:09:19 -0400941 XCB_EVENT_MASK_POINTER_MOTION |
942 XCB_EVENT_MASK_ENTER_WINDOW |
943 XCB_EVENT_MASK_LEAVE_WINDOW |
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400944 XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
Kristian Høgsberg44c20132012-05-30 10:09:21 -0400945 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
Kristian Høgsbergf9187192013-05-02 13:43:24 -0400946 values[2] = wm->colormap;
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400947
948 window->frame_id = xcb_generate_id(wm->conn);
949 xcb_create_window(wm->conn,
Kristian Høgsbergf9187192013-05-02 13:43:24 -0400950 32,
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400951 window->frame_id,
952 wm->screen->root,
953 0, 0,
954 width, height,
955 0,
956 XCB_WINDOW_CLASS_INPUT_OUTPUT,
Kristian Høgsbergf9187192013-05-02 13:43:24 -0400957 wm->visual_id,
958 XCB_CW_BORDER_PIXEL |
959 XCB_CW_EVENT_MASK |
960 XCB_CW_COLORMAP, values);
961
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400962 xcb_reparent_window(wm->conn, window->id, window->frame_id, x, y);
963
964 values[0] = 0;
965 xcb_configure_window(wm->conn, window->id,
966 XCB_CONFIG_WINDOW_BORDER_WIDTH, values);
967
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400968 window->cairo_surface =
969 cairo_xcb_surface_create_with_xrender_format(wm->conn,
970 wm->screen,
971 window->frame_id,
Kristian Høgsbergf9187192013-05-02 13:43:24 -0400972 &wm->format_rgba,
Kristian Høgsberg380deee2012-05-21 17:12:41 -0400973 width, height);
974
975 hash_table_insert(wm->window_hash, window->frame_id, window);
976}
977
Giulio Camuffoe90ea442014-12-13 18:06:34 +0200978/*
979 * Sets the _NET_WM_DESKTOP property for the window to 'desktop'.
980 * Passing a <0 desktop value deletes the property.
981 */
982static void
983weston_wm_window_set_virtual_desktop(struct weston_wm_window *window,
Bryce Harringtone00554b2015-06-12 10:17:39 -0700984 int desktop)
Giulio Camuffoe90ea442014-12-13 18:06:34 +0200985{
986 if (desktop >= 0) {
987 xcb_change_property(window->wm->conn,
988 XCB_PROP_MODE_REPLACE,
989 window->id,
990 window->wm->atom.net_wm_desktop,
991 XCB_ATOM_CARDINAL,
992 32, /* format */
993 1, &desktop);
994 } else {
995 xcb_delete_property(window->wm->conn,
996 window->id,
997 window->wm->atom.net_wm_desktop);
998 }
999}
1000
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001001static void
Kristian Høgsberg318ea372013-09-03 16:19:18 -07001002weston_wm_handle_map_request(struct weston_wm *wm, xcb_generic_event_t *event)
1003{
1004 xcb_map_request_event_t *map_request =
1005 (xcb_map_request_event_t *) event;
1006 struct weston_wm_window *window;
Pekka Paalanen505237e2016-12-01 15:41:11 +02001007 struct weston_output *output;
Kristian Høgsberg318ea372013-09-03 16:19:18 -07001008
1009 if (our_resource(wm, map_request->window)) {
1010 wm_log("XCB_MAP_REQUEST (window %d, ours)\n",
1011 map_request->window);
1012 return;
1013 }
1014
Derek Foreman49372142015-04-09 10:51:22 -05001015 if (!wm_lookup_window(wm, map_request->window, &window))
1016 return;
Kristian Høgsberg318ea372013-09-03 16:19:18 -07001017
1018 weston_wm_window_read_properties(window);
1019
Pekka Paalanenc9ca2c02016-12-15 16:04:14 +02001020 /* For a new Window, MapRequest happens before the Window is realized
1021 * in Xwayland. We do the real xcb_map_window() here as a response to
1022 * MapRequest. The Window will get realized (wl_surface created in
1023 * Wayland and WL_SURFACE_ID sent in X11) when it has been mapped for
1024 * real.
1025 *
1026 * MapRequest only happens for (X11) unmapped Windows. On UnmapNotify,
1027 * we reset shsurf to NULL, so even if X11 connection races far ahead
1028 * of the Wayland connection and the X11 client is repeatedly mapping
1029 * and unmapping, we will never have shsurf set on MapRequest.
1030 */
1031 assert(!window->shsurf);
1032
Kristian Høgsberg318ea372013-09-03 16:19:18 -07001033 if (window->frame_id == XCB_WINDOW_NONE)
1034 weston_wm_window_create_frame(window);
1035
Pekka Paalanen44660c32016-11-14 15:38:43 +02001036 wm_log("XCB_MAP_REQUEST (window %d, %p, frame %d, %dx%d @ %d,%d)\n",
1037 window->id, window, window->frame_id,
1038 window->width, window->height, window->x, window->y);
Kristian Høgsberg318ea372013-09-03 16:19:18 -07001039
1040 weston_wm_window_set_wm_state(window, ICCCM_NORMAL_STATE);
1041 weston_wm_window_set_net_wm_state(window);
Giulio Camuffoe90ea442014-12-13 18:06:34 +02001042 weston_wm_window_set_virtual_desktop(window, 0);
Kristian Høgsberg318ea372013-09-03 16:19:18 -07001043
Pekka Paalanen505237e2016-12-01 15:41:11 +02001044 if (legacy_fullscreen(wm, window, &output)) {
1045 window->fullscreen = 1;
1046 weston_output_weak_ref_set(&window->legacy_fullscreen_output,
1047 output);
1048 }
1049
Kristian Høgsberg318ea372013-09-03 16:19:18 -07001050 xcb_map_window(wm->conn, map_request->window);
1051 xcb_map_window(wm->conn, window->frame_id);
1052}
1053
1054static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001055weston_wm_handle_map_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1056{
1057 xcb_map_notify_event_t *map_notify = (xcb_map_notify_event_t *) event;
1058
1059 if (our_resource(wm, map_notify->window)) {
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001060 wm_log("XCB_MAP_NOTIFY (window %d, ours)\n",
1061 map_notify->window);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001062 return;
1063 }
1064
Pekka Paalanen73428a82016-12-19 15:10:01 +02001065 wm_log("XCB_MAP_NOTIFY (window %d%s)\n", map_notify->window,
1066 map_notify->override_redirect ? ", override" : "");
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001067}
1068
1069static void
Kristian Høgsberg194ea542012-05-30 10:05:41 -04001070weston_wm_handle_unmap_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1071{
1072 xcb_unmap_notify_event_t *unmap_notify =
1073 (xcb_unmap_notify_event_t *) event;
1074 struct weston_wm_window *window;
1075
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001076 wm_log("XCB_UNMAP_NOTIFY (window %d, event %d%s)\n",
1077 unmap_notify->window,
1078 unmap_notify->event,
1079 our_resource(wm, unmap_notify->window) ? ", ours" : "");
Kristian Høgsberg194ea542012-05-30 10:05:41 -04001080
1081 if (our_resource(wm, unmap_notify->window))
1082 return;
1083
MoD31700122013-06-11 19:58:55 -05001084 if (unmap_notify->response_type & SEND_EVENT_MASK)
Kristian Høgsbergd64bdf42012-05-31 10:33:43 -04001085 /* We just ignore the ICCCM 4.1.4 synthetic unmap notify
1086 * as it may come in after we've destroyed the window. */
Kristian Høgsbergf197e9f2012-05-30 11:46:29 -04001087 return;
Kristian Høgsbergf197e9f2012-05-30 11:46:29 -04001088
Derek Foreman49372142015-04-09 10:51:22 -05001089 if (!wm_lookup_window(wm, unmap_notify->window, &window))
1090 return;
1091
Derek Foreman9a0b2b52015-04-09 14:48:22 -05001092 if (window->surface_id) {
1093 /* Make sure we're not on the unpaired surface list or we
1094 * could be assigned a surface during surface creation that
1095 * was mapped before this unmap request.
1096 */
1097 wl_list_remove(&window->link);
1098 window->surface_id = 0;
1099 }
Kristian Høgsberg194ea542012-05-30 10:05:41 -04001100 if (wm->focus_window == window)
1101 wm->focus_window = NULL;
Kristian Høgsberg194ea542012-05-30 10:05:41 -04001102 if (window->surface)
1103 wl_list_remove(&window->surface_destroy_listener.link);
1104 window->surface = NULL;
Giulio Camuffo85739ea2013-09-17 16:43:45 +02001105 window->shsurf = NULL;
Giulio Camuffoe90ea442014-12-13 18:06:34 +02001106
1107 weston_wm_window_set_wm_state(window, ICCCM_WITHDRAWN_STATE);
1108 weston_wm_window_set_virtual_desktop(window, -1);
1109
Kristian Høgsbergab6d6672013-09-03 16:38:51 -07001110 xcb_unmap_window(wm->conn, window->frame_id);
Kristian Høgsberg194ea542012-05-30 10:05:41 -04001111}
1112
1113static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001114weston_wm_window_draw_decoration(void *data)
1115{
1116 struct weston_wm_window *window = data;
1117 struct weston_wm *wm = window->wm;
1118 struct theme *t = wm->theme;
1119 cairo_t *cr;
1120 int x, y, width, height;
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001121 int32_t input_x, input_y, input_w, input_h;
Quentin Glidic955cec02016-08-12 10:41:35 +02001122 const struct weston_desktop_xwayland_interface *xwayland_interface =
1123 wm->server->compositor->xwayland_interface;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001124 uint32_t flags = 0;
Giulio Camuffoaa974782015-02-01 16:18:51 +02001125 struct weston_view *view;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001126
Pekka Paalanena04eacc2016-11-28 16:42:25 +02001127 wm_log("XWM: start draw decoration, win %d\n", window->id);
1128
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001129 weston_wm_window_read_properties(window);
1130
1131 window->repaint_source = NULL;
1132
1133 weston_wm_window_get_frame_size(window, &width, &height);
1134 weston_wm_window_get_child_position(window, &x, &y);
1135
1136 cairo_xcb_surface_set_size(window->cairo_surface, width, height);
1137 cr = cairo_create(window->cairo_surface);
1138
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05001139 if (window->fullscreen) {
1140 /* nothing */
1141 } else if (window->decorate) {
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001142 if (wm->focus_window == window)
1143 flags |= THEME_FRAME_ACTIVE;
1144
Pekka Paalanen9a330e12016-12-15 15:37:24 +02001145 frame_set_title(window->frame, window->name);
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001146 frame_repaint(window->frame, cr);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001147 } else {
1148 cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
1149 cairo_set_source_rgba(cr, 0, 0, 0, 0);
1150 cairo_paint(cr);
1151
Marek Chalupa0d7fe8d2014-10-29 14:51:22 +01001152 render_shadow(cr, t->shadow, 2, 2, width + 8, height + 8, 64, 64);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001153 }
1154
1155 cairo_destroy(cr);
1156
1157 if (window->surface) {
Scott Moreau76d8fc82012-11-22 15:35:13 -07001158 pixman_region32_fini(&window->surface->pending.opaque);
Dawid Gajownik74a635b2015-08-06 17:12:19 -03001159 if (window->has_alpha) {
MoD384a11a2013-06-22 11:04:21 -05001160 pixman_region32_init(&window->surface->pending.opaque);
1161 } else {
1162 /* We leave an extra pixel around the X window area to
1163 * make sure we don't sample from the undefined alpha
1164 * channel when filtering. */
Murray Calavera883ac022015-06-06 13:02:22 +00001165 pixman_region32_init_rect(&window->surface->pending.opaque,
MoD384a11a2013-06-22 11:04:21 -05001166 x - 1, y - 1,
1167 window->width + 2,
1168 window->height + 2);
1169 }
Giulio Camuffoaa974782015-02-01 16:18:51 +02001170 wl_list_for_each(view, &window->surface->views, surface_link)
1171 weston_view_geometry_dirty(view);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001172
Kristian Høgsberg81585e92013-02-14 22:01:58 -05001173 pixman_region32_fini(&window->surface->pending.input);
Kristian Høgsberg1d75c7d2013-10-30 23:46:08 -07001174
Jasper St. Pierred19e9b02015-03-21 21:24:43 -07001175 if (window->decorate && !window->fullscreen) {
Kristian Høgsberg1d75c7d2013-10-30 23:46:08 -07001176 frame_input_rect(window->frame, &input_x, &input_y,
1177 &input_w, &input_h);
Jasper St. Pierred19e9b02015-03-21 21:24:43 -07001178 } else {
1179 input_x = x;
1180 input_y = y;
1181 input_w = width;
1182 input_h = height;
Kristian Høgsberg1d75c7d2013-10-30 23:46:08 -07001183 }
1184
Kristian Høgsbergd8b617d2013-02-14 21:56:32 -05001185 pixman_region32_init_rect(&window->surface->pending.input,
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001186 input_x, input_y, input_w, input_h);
Jasper St. Pierreccf48fb2014-05-02 10:21:38 -04001187
Pekka Paalanena04eacc2016-11-28 16:42:25 +02001188 wm_log("XWM: draw decoration, win %d geometry: %d,%d %dx%d\n",
1189 window->id, input_x, input_y, input_w, input_h);
1190
Quentin Glidic955cec02016-08-12 10:41:35 +02001191 xwayland_interface->set_window_geometry(window->shsurf,
1192 input_x, input_y, input_w, input_h);
Pekka Paalanenc9ca2c02016-12-15 16:04:14 +02001193 if (window->name)
1194 xwayland_interface->set_title(window->shsurf, window->name);
1195 if (window->pid > 0)
1196 xwayland_interface->set_pid(window->shsurf, window->pid);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001197 }
1198}
1199
1200static void
1201weston_wm_window_schedule_repaint(struct weston_wm_window *window)
1202{
1203 struct weston_wm *wm = window->wm;
Giulio Camuffoaa974782015-02-01 16:18:51 +02001204 struct weston_view *view;
Pekka Paalanen4f9c07b2012-09-03 16:48:41 +03001205 int width, height;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001206
Kristian Høgsbergc4063f32012-07-22 15:32:45 -04001207 if (window->frame_id == XCB_WINDOW_NONE) {
1208 if (window->surface != NULL) {
Pekka Paalanen73428a82016-12-19 15:10:01 +02001209 /* Override-redirect windows go through here, but we
1210 * cannot assert(window->override_redirect); because
1211 * we do not deal with changing OR flag yet.
1212 * XXX: handle OR flag changes in message handlers
1213 */
Pekka Paalanen4f9c07b2012-09-03 16:48:41 +03001214 weston_wm_window_get_frame_size(window, &width, &height);
Scott Moreau76d8fc82012-11-22 15:35:13 -07001215 pixman_region32_fini(&window->surface->pending.opaque);
Dawid Gajownik74a635b2015-08-06 17:12:19 -03001216 if (window->has_alpha) {
MoD384a11a2013-06-22 11:04:21 -05001217 pixman_region32_init(&window->surface->pending.opaque);
1218 } else {
1219 pixman_region32_init_rect(&window->surface->pending.opaque, 0, 0,
1220 width, height);
1221 }
Giulio Camuffoaa974782015-02-01 16:18:51 +02001222 wl_list_for_each(view, &window->surface->views, surface_link)
1223 weston_view_geometry_dirty(view);
Kristian Høgsbergc4063f32012-07-22 15:32:45 -04001224 }
1225 return;
1226 }
1227
1228 if (window->repaint_source)
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001229 return;
1230
Pekka Paalanena04eacc2016-11-28 16:42:25 +02001231 wm_log("XWM: schedule repaint, win %d\n", window->id);
1232
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001233 window->repaint_source =
1234 wl_event_loop_add_idle(wm->server->loop,
1235 weston_wm_window_draw_decoration,
1236 window);
1237}
1238
1239static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001240weston_wm_handle_property_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1241{
1242 xcb_property_notify_event_t *property_notify =
1243 (xcb_property_notify_event_t *) event;
1244 struct weston_wm_window *window;
1245
Derek Foreman49372142015-04-09 10:51:22 -05001246 if (!wm_lookup_window(wm, property_notify->window, &window))
Rob Bradfordaa521bd2013-01-10 19:48:57 +00001247 return;
1248
1249 window->properties_dirty = 1;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001250
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001251 wm_log("XCB_PROPERTY_NOTIFY: window %d, ", property_notify->window);
Kristian Høgsberge244cb02012-05-30 11:34:35 -04001252 if (property_notify->state == XCB_PROPERTY_DELETE)
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001253 wm_log("deleted\n");
Kristian Høgsberge244cb02012-05-30 11:34:35 -04001254 else
1255 read_and_dump_property(wm, property_notify->window,
1256 property_notify->atom);
Kristian Høgsberg0273b572012-05-30 09:58:02 -04001257
1258 if (property_notify->atom == wm->atom.net_wm_name ||
1259 property_notify->atom == XCB_ATOM_WM_NAME)
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001260 weston_wm_window_schedule_repaint(window);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001261}
1262
1263static void
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001264weston_wm_window_create(struct weston_wm *wm,
Giulio Camuffoca43f092013-09-11 17:49:13 +02001265 xcb_window_t id, int width, int height, int x, int y, int override)
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001266{
1267 struct weston_wm_window *window;
1268 uint32_t values[1];
MoD384a11a2013-06-22 11:04:21 -05001269 xcb_get_geometry_cookie_t geometry_cookie;
1270 xcb_get_geometry_reply_t *geometry_reply;
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001271
Peter Huttererf3d62272013-08-08 11:57:05 +10001272 window = zalloc(sizeof *window);
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001273 if (window == NULL) {
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001274 wm_log("failed to allocate window\n");
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001275 return;
1276 }
1277
MoD384a11a2013-06-22 11:04:21 -05001278 geometry_cookie = xcb_get_geometry(wm->conn, id);
1279
Giulio Camuffob18f7882015-03-29 14:20:23 +03001280 values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE |
1281 XCB_EVENT_MASK_FOCUS_CHANGE;
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001282 xcb_change_window_attributes(wm->conn, id, XCB_CW_EVENT_MASK, values);
1283
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001284 window->wm = wm;
1285 window->id = id;
1286 window->properties_dirty = 1;
Tiago Vignatti771241e2012-06-04 20:01:45 +03001287 window->override_redirect = override;
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001288 window->width = width;
1289 window->height = height;
Giulio Camuffoca43f092013-09-11 17:49:13 +02001290 window->x = x;
1291 window->y = y;
Giulio Camuffof05d18f2015-12-11 20:57:05 +02001292 window->pos_dirty = false;
Pekka Paalanen505237e2016-12-01 15:41:11 +02001293 weston_output_weak_ref_init(&window->legacy_fullscreen_output);
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001294
MoD384a11a2013-06-22 11:04:21 -05001295 geometry_reply = xcb_get_geometry_reply(wm->conn, geometry_cookie, NULL);
1296 /* technically we should use XRender and check the visual format's
1297 alpha_mask, but checking depth is simpler and works in all known cases */
Dawid Gajownik74a635b2015-08-06 17:12:19 -03001298 if (geometry_reply != NULL)
MoD384a11a2013-06-22 11:04:21 -05001299 window->has_alpha = geometry_reply->depth == 32;
1300 free(geometry_reply);
1301
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001302 hash_table_insert(wm->window_hash, id, window);
1303}
1304
1305static void
1306weston_wm_window_destroy(struct weston_wm_window *window)
1307{
Kristian Høgsbergab6d6672013-09-03 16:38:51 -07001308 struct weston_wm *wm = window->wm;
1309
Pekka Paalanen505237e2016-12-01 15:41:11 +02001310 weston_output_weak_ref_clear(&window->legacy_fullscreen_output);
1311
Kristian Høgsbergab6d6672013-09-03 16:38:51 -07001312 if (window->repaint_source)
1313 wl_event_source_remove(window->repaint_source);
1314 if (window->cairo_surface)
1315 cairo_surface_destroy(window->cairo_surface);
1316
1317 if (window->frame_id) {
1318 xcb_reparent_window(wm->conn, window->id, wm->wm_window, 0, 0);
1319 xcb_destroy_window(wm->conn, window->frame_id);
1320 weston_wm_window_set_wm_state(window, ICCCM_WITHDRAWN_STATE);
Giulio Camuffoe90ea442014-12-13 18:06:34 +02001321 weston_wm_window_set_virtual_desktop(window, -1);
Kristian Høgsbergab6d6672013-09-03 16:38:51 -07001322 hash_table_remove(wm->window_hash, window->frame_id);
1323 window->frame_id = XCB_WINDOW_NONE;
1324 }
1325
Kristian Høgsbergba83db22014-04-07 10:16:19 -07001326 if (window->surface_id)
1327 wl_list_remove(&window->link);
1328
Derek Foreman9a0b2b52015-04-09 14:48:22 -05001329 if (window->surface)
1330 wl_list_remove(&window->surface_destroy_listener.link);
1331
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001332 hash_table_remove(window->wm->window_hash, window->id);
1333 free(window);
1334}
1335
1336static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001337weston_wm_handle_create_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1338{
1339 xcb_create_notify_event_t *create_notify =
1340 (xcb_create_notify_event_t *) event;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001341
Pekka Paalanen7db6c432016-11-14 14:30:57 +02001342 wm_log("XCB_CREATE_NOTIFY (window %d, at (%d, %d), width %d, height %d%s%s)\n",
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001343 create_notify->window,
Pekka Paalanen7db6c432016-11-14 14:30:57 +02001344 create_notify->x, create_notify->y,
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001345 create_notify->width, create_notify->height,
1346 create_notify->override_redirect ? ", override" : "",
1347 our_resource(wm, create_notify->window) ? ", ours" : "");
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001348
1349 if (our_resource(wm, create_notify->window))
1350 return;
1351
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001352 weston_wm_window_create(wm, create_notify->window,
Tiago Vignatti771241e2012-06-04 20:01:45 +03001353 create_notify->width, create_notify->height,
Giulio Camuffoca43f092013-09-11 17:49:13 +02001354 create_notify->x, create_notify->y,
Tiago Vignatti771241e2012-06-04 20:01:45 +03001355 create_notify->override_redirect);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001356}
1357
1358static void
1359weston_wm_handle_destroy_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1360{
1361 xcb_destroy_notify_event_t *destroy_notify =
1362 (xcb_destroy_notify_event_t *) event;
1363 struct weston_wm_window *window;
1364
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001365 wm_log("XCB_DESTROY_NOTIFY, win %d, event %d%s\n",
1366 destroy_notify->window,
1367 destroy_notify->event,
1368 our_resource(wm, destroy_notify->window) ? ", ours" : "");
Kristian Høgsberg194ea542012-05-30 10:05:41 -04001369
1370 if (our_resource(wm, destroy_notify->window))
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001371 return;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001372
Derek Foreman49372142015-04-09 10:51:22 -05001373 if (!wm_lookup_window(wm, destroy_notify->window, &window))
1374 return;
1375
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001376 weston_wm_window_destroy(window);
1377}
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001378
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001379static void
1380weston_wm_handle_reparent_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1381{
1382 xcb_reparent_notify_event_t *reparent_notify =
1383 (xcb_reparent_notify_event_t *) event;
1384 struct weston_wm_window *window;
Kristian Høgsbergc9571fb2012-05-29 15:35:29 -04001385
Pekka Paalanen73428a82016-12-19 15:10:01 +02001386 wm_log("XCB_REPARENT_NOTIFY (window %d, parent %d, event %d%s)\n",
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001387 reparent_notify->window,
1388 reparent_notify->parent,
Pekka Paalanen73428a82016-12-19 15:10:01 +02001389 reparent_notify->event,
1390 reparent_notify->override_redirect ? ", override" : "");
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001391
1392 if (reparent_notify->parent == wm->screen->root) {
Tiago Vignatti771241e2012-06-04 20:01:45 +03001393 weston_wm_window_create(wm, reparent_notify->window, 10, 10,
Giulio Camuffoca43f092013-09-11 17:49:13 +02001394 reparent_notify->x, reparent_notify->y,
Tiago Vignatti771241e2012-06-04 20:01:45 +03001395 reparent_notify->override_redirect);
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001396 } else if (!our_resource(wm, reparent_notify->parent)) {
Derek Foreman49372142015-04-09 10:51:22 -05001397 if (!wm_lookup_window(wm, reparent_notify->window, &window))
1398 return;
Kristian Høgsberg029539b2012-05-30 11:28:24 -04001399 weston_wm_window_destroy(window);
1400 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001401}
1402
Kristian Høgsberg5ba31892012-08-10 10:06:59 -04001403struct weston_seat *
1404weston_wm_pick_seat(struct weston_wm *wm)
1405{
Tom Hochsteine7fff212016-11-01 14:14:00 -05001406 struct wl_list *seats = wm->server->compositor->seat_list.next;
1407 if (wl_list_empty(seats))
1408 return NULL;
1409 return container_of(seats, struct weston_seat, link);
Kristian Høgsberg5ba31892012-08-10 10:06:59 -04001410}
1411
Kristian Høgsberg052ef4e2014-04-30 16:10:14 -07001412static struct weston_seat *
1413weston_wm_pick_seat_for_window(struct weston_wm_window *window)
1414{
1415 struct weston_wm *wm = window->wm;
1416 struct weston_seat *seat, *s;
1417
1418 seat = NULL;
1419 wl_list_for_each(s, &wm->server->compositor->seat_list, link) {
Derek Foreman1281a362015-07-31 16:55:32 -05001420 struct weston_pointer *pointer = weston_seat_get_pointer(s);
1421 struct weston_pointer *old_pointer =
1422 weston_seat_get_pointer(seat);
1423
1424 if (pointer && pointer->focus &&
1425 pointer->focus->surface == window->surface &&
1426 pointer->button_count > 0 &&
1427 (!seat ||
1428 pointer->grab_serial -
1429 old_pointer->grab_serial < (1 << 30)))
Kristian Høgsberg052ef4e2014-04-30 16:10:14 -07001430 seat = s;
1431 }
1432
1433 return seat;
1434}
1435
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001436static void
Kristian Høgsberge68fd102012-05-22 17:09:40 -04001437weston_wm_window_handle_moveresize(struct weston_wm_window *window,
1438 xcb_client_message_event_t *client_message)
1439{
1440 static const int map[] = {
1441 THEME_LOCATION_RESIZING_TOP_LEFT,
1442 THEME_LOCATION_RESIZING_TOP,
1443 THEME_LOCATION_RESIZING_TOP_RIGHT,
1444 THEME_LOCATION_RESIZING_RIGHT,
1445 THEME_LOCATION_RESIZING_BOTTOM_RIGHT,
1446 THEME_LOCATION_RESIZING_BOTTOM,
1447 THEME_LOCATION_RESIZING_BOTTOM_LEFT,
1448 THEME_LOCATION_RESIZING_LEFT
1449 };
1450
1451 struct weston_wm *wm = window->wm;
Kristian Høgsberg052ef4e2014-04-30 16:10:14 -07001452 struct weston_seat *seat = weston_wm_pick_seat_for_window(window);
Derek Foreman1281a362015-07-31 16:55:32 -05001453 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
Kristian Høgsberge68fd102012-05-22 17:09:40 -04001454 int detail;
Quentin Glidic955cec02016-08-12 10:41:35 +02001455 const struct weston_desktop_xwayland_interface *xwayland_interface =
1456 wm->server->compositor->xwayland_interface;
Kristian Høgsberge68fd102012-05-22 17:09:40 -04001457
Derek Foreman1281a362015-07-31 16:55:32 -05001458 if (!pointer || pointer->button_count != 1
1459 || !pointer->focus
1460 || pointer->focus->surface != window->surface)
Kristian Høgsberge68fd102012-05-22 17:09:40 -04001461 return;
1462
1463 detail = client_message->data.data32[2];
1464 switch (detail) {
1465 case _NET_WM_MOVERESIZE_MOVE:
Quentin Glidic955cec02016-08-12 10:41:35 +02001466 xwayland_interface->move(window->shsurf, pointer);
Kristian Høgsberge68fd102012-05-22 17:09:40 -04001467 break;
1468 case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
1469 case _NET_WM_MOVERESIZE_SIZE_TOP:
1470 case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
1471 case _NET_WM_MOVERESIZE_SIZE_RIGHT:
1472 case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
1473 case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
1474 case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
1475 case _NET_WM_MOVERESIZE_SIZE_LEFT:
Quentin Glidic955cec02016-08-12 10:41:35 +02001476 xwayland_interface->resize(window->shsurf, pointer, map[detail]);
Kristian Høgsberge68fd102012-05-22 17:09:40 -04001477 break;
1478 case _NET_WM_MOVERESIZE_CANCEL:
1479 break;
1480 }
1481}
1482
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05001483#define _NET_WM_STATE_REMOVE 0
1484#define _NET_WM_STATE_ADD 1
1485#define _NET_WM_STATE_TOGGLE 2
1486
1487static int
1488update_state(int action, int *state)
1489{
1490 int new_state, changed;
1491
1492 switch (action) {
1493 case _NET_WM_STATE_REMOVE:
1494 new_state = 0;
1495 break;
1496 case _NET_WM_STATE_ADD:
1497 new_state = 1;
1498 break;
1499 case _NET_WM_STATE_TOGGLE:
1500 new_state = !*state;
1501 break;
1502 default:
1503 return 0;
1504 }
1505
1506 changed = (*state != new_state);
1507 *state = new_state;
1508
1509 return changed;
1510}
1511
1512static void
1513weston_wm_window_configure(void *data);
1514
1515static void
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02001516weston_wm_window_set_toplevel(struct weston_wm_window *window)
1517{
Quentin Glidic955cec02016-08-12 10:41:35 +02001518 const struct weston_desktop_xwayland_interface *xwayland_interface =
1519 window->wm->server->compositor->xwayland_interface;
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02001520
Quentin Glidic955cec02016-08-12 10:41:35 +02001521 xwayland_interface->set_toplevel(window->shsurf);
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02001522 window->width = window->saved_width;
1523 window->height = window->saved_height;
1524 if (window->frame)
1525 frame_resize_inside(window->frame,
1526 window->width,
1527 window->height);
1528 weston_wm_window_configure(window);
1529}
1530
1531static inline bool
1532weston_wm_window_is_maximized(struct weston_wm_window *window)
1533{
1534 return window->maximized_horz && window->maximized_vert;
1535}
1536
1537static void
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05001538weston_wm_window_handle_state(struct weston_wm_window *window,
1539 xcb_client_message_event_t *client_message)
1540{
1541 struct weston_wm *wm = window->wm;
Quentin Glidic955cec02016-08-12 10:41:35 +02001542 const struct weston_desktop_xwayland_interface *xwayland_interface =
1543 wm->server->compositor->xwayland_interface;
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05001544 uint32_t action, property;
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02001545 int maximized = weston_wm_window_is_maximized(window);
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05001546
1547 action = client_message->data.data32[0];
1548 property = client_message->data.data32[1];
1549
1550 if (property == wm->atom.net_wm_state_fullscreen &&
1551 update_state(action, &window->fullscreen)) {
1552 weston_wm_window_set_net_wm_state(window);
1553 if (window->fullscreen) {
1554 window->saved_width = window->width;
1555 window->saved_height = window->height;
Kristian Høgsberg762b1662013-02-21 20:18:37 -05001556
1557 if (window->shsurf)
Quentin Glidic955cec02016-08-12 10:41:35 +02001558 xwayland_interface->set_fullscreen(window->shsurf,
1559 NULL);
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05001560 } else {
Andrew Engelbrecht4c5a6f72014-12-02 12:18:44 -05001561 if (window->shsurf)
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02001562 weston_wm_window_set_toplevel(window);
1563 }
1564 } else {
1565 if (property == wm->atom.net_wm_state_maximized_vert &&
1566 update_state(action, &window->maximized_vert))
1567 weston_wm_window_set_net_wm_state(window);
1568 if (property == wm->atom.net_wm_state_maximized_horz &&
1569 update_state(action, &window->maximized_horz))
1570 weston_wm_window_set_net_wm_state(window);
Andrew Engelbrecht4c5a6f72014-12-02 12:18:44 -05001571
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02001572 if (maximized != weston_wm_window_is_maximized(window)) {
1573 if (weston_wm_window_is_maximized(window)) {
1574 window->saved_width = window->width;
1575 window->saved_height = window->height;
1576
1577 if (window->shsurf)
Quentin Glidic955cec02016-08-12 10:41:35 +02001578 xwayland_interface->set_maximized(window->shsurf);
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02001579 } else if (window->shsurf) {
1580 weston_wm_window_set_toplevel(window);
1581 }
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05001582 }
1583 }
1584}
1585
Kristian Høgsberge68fd102012-05-22 17:09:40 -04001586static void
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07001587surface_destroy(struct wl_listener *listener, void *data)
1588{
1589 struct weston_wm_window *window =
1590 container_of(listener,
1591 struct weston_wm_window, surface_destroy_listener);
1592
1593 wm_log("surface for xid %d destroyed\n", window->id);
1594
1595 /* This should have been freed by the shell.
1596 * Don't try to use it later. */
1597 window->shsurf = NULL;
1598 window->surface = NULL;
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07001599}
1600
1601static void
1602weston_wm_window_handle_surface_id(struct weston_wm_window *window,
1603 xcb_client_message_event_t *client_message)
1604{
1605 struct weston_wm *wm = window->wm;
1606 struct wl_resource *resource;
1607
1608 if (window->surface_id != 0) {
1609 wm_log("already have surface id for window %d\n", window->id);
1610 return;
1611 }
1612
1613 /* Xwayland will send the wayland requests to create the
1614 * wl_surface before sending this client message. Even so, we
1615 * can end up handling the X event before the wayland requests
1616 * and thus when we try to look up the surface ID, the surface
1617 * hasn't been created yet. In that case put the window on
1618 * the unpaired window list and continue when the surface gets
1619 * created. */
Jason Ekstrand4ff4d922014-07-24 13:16:58 -07001620 uint32_t id = client_message->data.data32[0];
1621 resource = wl_client_get_object(wm->server->client, id);
Tyler Venesscf4c13a2014-07-02 15:00:44 -07001622 if (resource) {
1623 window->surface_id = 0;
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07001624 xserver_map_shell_surface(window,
1625 wl_resource_get_user_data(resource));
Tyler Venesscf4c13a2014-07-02 15:00:44 -07001626 }
1627 else {
Jason Ekstrand4ff4d922014-07-24 13:16:58 -07001628 window->surface_id = id;
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07001629 wl_list_insert(&wm->unpaired_window_list, &window->link);
Tyler Venesscf4c13a2014-07-02 15:00:44 -07001630 }
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07001631}
1632
1633static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001634weston_wm_handle_client_message(struct weston_wm *wm,
1635 xcb_generic_event_t *event)
1636{
1637 xcb_client_message_event_t *client_message =
1638 (xcb_client_message_event_t *) event;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001639 struct weston_wm_window *window;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001640
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001641 wm_log("XCB_CLIENT_MESSAGE (%s %d %d %d %d %d win %d)\n",
1642 get_atom_name(wm->conn, client_message->type),
1643 client_message->data.data32[0],
1644 client_message->data.data32[1],
1645 client_message->data.data32[2],
1646 client_message->data.data32[3],
1647 client_message->data.data32[4],
1648 client_message->window);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001649
Jason Ekstrand0250a742014-07-24 13:17:47 -07001650 /* The window may get created and destroyed before we actually
1651 * handle the message. If it doesn't exist, bail.
1652 */
Derek Foreman49372142015-04-09 10:51:22 -05001653 if (!wm_lookup_window(wm, client_message->window, &window))
Jason Ekstrand0250a742014-07-24 13:17:47 -07001654 return;
1655
Kristian Høgsberge68fd102012-05-22 17:09:40 -04001656 if (client_message->type == wm->atom.net_wm_moveresize)
1657 weston_wm_window_handle_moveresize(window, client_message);
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05001658 else if (client_message->type == wm->atom.net_wm_state)
1659 weston_wm_window_handle_state(window, client_message);
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07001660 else if (client_message->type == wm->atom.wl_surface_id)
1661 weston_wm_window_handle_surface_id(window, client_message);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001662}
1663
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001664enum cursor_type {
1665 XWM_CURSOR_TOP,
1666 XWM_CURSOR_BOTTOM,
1667 XWM_CURSOR_LEFT,
1668 XWM_CURSOR_RIGHT,
1669 XWM_CURSOR_TOP_LEFT,
1670 XWM_CURSOR_TOP_RIGHT,
1671 XWM_CURSOR_BOTTOM_LEFT,
1672 XWM_CURSOR_BOTTOM_RIGHT,
1673 XWM_CURSOR_LEFT_PTR,
1674};
1675
Giulio Camuffoa2df51c2013-09-18 15:20:04 +02001676/*
1677 * The following correspondences between file names and cursors was copied
1678 * from: https://bugs.kde.org/attachment.cgi?id=67313
1679 */
1680
1681static const char *bottom_left_corners[] = {
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001682 "bottom_left_corner",
Giulio Camuffoa2df51c2013-09-18 15:20:04 +02001683 "sw-resize",
1684 "size_bdiag"
1685};
1686
1687static const char *bottom_right_corners[] = {
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001688 "bottom_right_corner",
Giulio Camuffoa2df51c2013-09-18 15:20:04 +02001689 "se-resize",
1690 "size_fdiag"
1691};
1692
1693static const char *bottom_sides[] = {
1694 "bottom_side",
1695 "s-resize",
1696 "size_ver"
1697};
1698
1699static const char *left_ptrs[] = {
1700 "left_ptr",
1701 "default",
1702 "top_left_arrow",
1703 "left-arrow"
1704};
1705
1706static const char *left_sides[] = {
1707 "left_side",
1708 "w-resize",
1709 "size_hor"
1710};
1711
1712static const char *right_sides[] = {
1713 "right_side",
1714 "e-resize",
1715 "size_hor"
1716};
1717
1718static const char *top_left_corners[] = {
1719 "top_left_corner",
1720 "nw-resize",
1721 "size_fdiag"
1722};
1723
1724static const char *top_right_corners[] = {
1725 "top_right_corner",
1726 "ne-resize",
1727 "size_bdiag"
1728};
1729
1730static const char *top_sides[] = {
1731 "top_side",
1732 "n-resize",
1733 "size_ver"
1734};
1735
1736struct cursor_alternatives {
1737 const char **names;
1738 size_t count;
1739};
1740
1741static const struct cursor_alternatives cursors[] = {
1742 {top_sides, ARRAY_LENGTH(top_sides)},
1743 {bottom_sides, ARRAY_LENGTH(bottom_sides)},
1744 {left_sides, ARRAY_LENGTH(left_sides)},
1745 {right_sides, ARRAY_LENGTH(right_sides)},
1746 {top_left_corners, ARRAY_LENGTH(top_left_corners)},
1747 {top_right_corners, ARRAY_LENGTH(top_right_corners)},
1748 {bottom_left_corners, ARRAY_LENGTH(bottom_left_corners)},
1749 {bottom_right_corners, ARRAY_LENGTH(bottom_right_corners)},
1750 {left_ptrs, ARRAY_LENGTH(left_ptrs)},
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001751};
1752
1753static void
1754weston_wm_create_cursors(struct weston_wm *wm)
1755{
Giulio Camuffoa2df51c2013-09-18 15:20:04 +02001756 const char *name;
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001757 int i, count = ARRAY_LENGTH(cursors);
Giulio Camuffoa2df51c2013-09-18 15:20:04 +02001758 size_t j;
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001759
1760 wm->cursors = malloc(count * sizeof(xcb_cursor_t));
1761 for (i = 0; i < count; i++) {
Giulio Camuffoa2df51c2013-09-18 15:20:04 +02001762 for (j = 0; j < cursors[i].count; j++) {
1763 name = cursors[i].names[j];
1764 wm->cursors[i] =
1765 xcb_cursor_library_load_cursor(wm, name);
1766 if (wm->cursors[i] != (xcb_cursor_t)-1)
1767 break;
1768 }
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001769 }
1770
1771 wm->last_cursor = -1;
1772}
1773
1774static void
1775weston_wm_destroy_cursors(struct weston_wm *wm)
1776{
1777 uint8_t i;
1778
1779 for (i = 0; i < ARRAY_LENGTH(cursors); i++)
1780 xcb_free_cursor(wm->conn, wm->cursors[i]);
1781
1782 free(wm->cursors);
1783}
1784
1785static int
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001786get_cursor_for_location(enum theme_location location)
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001787{
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001788 switch (location) {
1789 case THEME_LOCATION_RESIZING_TOP:
1790 return XWM_CURSOR_TOP;
1791 case THEME_LOCATION_RESIZING_BOTTOM:
1792 return XWM_CURSOR_BOTTOM;
1793 case THEME_LOCATION_RESIZING_LEFT:
1794 return XWM_CURSOR_LEFT;
1795 case THEME_LOCATION_RESIZING_RIGHT:
1796 return XWM_CURSOR_RIGHT;
1797 case THEME_LOCATION_RESIZING_TOP_LEFT:
1798 return XWM_CURSOR_TOP_LEFT;
1799 case THEME_LOCATION_RESIZING_TOP_RIGHT:
1800 return XWM_CURSOR_TOP_RIGHT;
1801 case THEME_LOCATION_RESIZING_BOTTOM_LEFT:
1802 return XWM_CURSOR_BOTTOM_LEFT;
1803 case THEME_LOCATION_RESIZING_BOTTOM_RIGHT:
1804 return XWM_CURSOR_BOTTOM_RIGHT;
1805 case THEME_LOCATION_EXTERIOR:
1806 case THEME_LOCATION_TITLEBAR:
1807 default:
1808 return XWM_CURSOR_LEFT_PTR;
1809 }
1810}
1811
1812static void
Tiago Vignattic1903232012-07-16 12:15:37 -04001813weston_wm_window_set_cursor(struct weston_wm *wm, xcb_window_t window_id,
1814 int cursor)
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001815{
1816 uint32_t cursor_value_list;
1817
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001818 if (wm->last_cursor == cursor)
1819 return;
1820
1821 wm->last_cursor = cursor;
1822
1823 cursor_value_list = wm->cursors[cursor];
Tiago Vignattic1903232012-07-16 12:15:37 -04001824 xcb_change_window_attributes (wm->conn, window_id,
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001825 XCB_CW_CURSOR, &cursor_value_list);
1826 xcb_flush(wm->conn);
1827}
1828
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001829static void
Kristian Høgsberg2cd6da12013-10-13 22:11:07 -07001830weston_wm_window_close(struct weston_wm_window *window, xcb_timestamp_t time)
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001831{
1832 xcb_client_message_event_t client_message;
1833
Kristian Høgsberg2cd6da12013-10-13 22:11:07 -07001834 if (window->delete_window) {
1835 client_message.response_type = XCB_CLIENT_MESSAGE;
1836 client_message.format = 32;
1837 client_message.window = window->id;
1838 client_message.type = window->wm->atom.wm_protocols;
1839 client_message.data.data32[0] =
1840 window->wm->atom.wm_delete_window;
1841 client_message.data.data32[1] = time;
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001842
Kristian Høgsberg2cd6da12013-10-13 22:11:07 -07001843 xcb_send_event(window->wm->conn, 0, window->id,
1844 XCB_EVENT_MASK_NO_EVENT,
1845 (char *) &client_message);
1846 } else {
1847 xcb_kill_client(window->wm->conn, window->id);
1848 }
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001849}
1850
1851static void
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001852weston_wm_handle_button(struct weston_wm *wm, xcb_generic_event_t *event)
1853{
1854 xcb_button_press_event_t *button = (xcb_button_press_event_t *) event;
Quentin Glidic955cec02016-08-12 10:41:35 +02001855 const struct weston_desktop_xwayland_interface *xwayland_interface =
1856 wm->server->compositor->xwayland_interface;
Kristian Høgsberg052ef4e2014-04-30 16:10:14 -07001857 struct weston_seat *seat;
Derek Foremane4d6c832015-08-05 14:48:11 -05001858 struct weston_pointer *pointer;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001859 struct weston_wm_window *window;
Kristian Høgsbergf96e6c02012-05-22 16:38:53 -04001860 enum theme_location location;
Quentin Glidicd8b17bc2016-07-10 11:00:55 +02001861 enum wl_pointer_button_state button_state;
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001862 uint32_t button_id;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001863
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04001864 wm_log("XCB_BUTTON_%s (detail %d)\n",
1865 button->response_type == XCB_BUTTON_PRESS ?
1866 "PRESS" : "RELEASE", button->detail);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001867
Derek Foreman49372142015-04-09 10:51:22 -05001868 if (!wm_lookup_window(wm, button->event, &window) ||
1869 !window->decorate)
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001870 return;
Kristian Høgsbergc1693f22012-05-22 16:56:23 -04001871
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001872 if (button->detail != 1 && button->detail != 2)
1873 return;
Kristian Høgsbergf96e6c02012-05-22 16:38:53 -04001874
Kristian Høgsberg052ef4e2014-04-30 16:10:14 -07001875 seat = weston_wm_pick_seat_for_window(window);
Derek Foremane4d6c832015-08-05 14:48:11 -05001876 pointer = weston_seat_get_pointer(seat);
Kristian Høgsberg052ef4e2014-04-30 16:10:14 -07001877
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001878 button_state = button->response_type == XCB_BUTTON_PRESS ?
Quentin Glidicd8b17bc2016-07-10 11:00:55 +02001879 WL_POINTER_BUTTON_STATE_PRESSED :
1880 WL_POINTER_BUTTON_STATE_RELEASED;
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001881 button_id = button->detail == 1 ? BTN_LEFT : BTN_RIGHT;
1882
Kristian Høgsberg8c3c7382014-04-30 16:52:30 -07001883 /* Make sure we're looking at the right location. The frame
1884 * could have received a motion event from a pointer from a
1885 * different wl_seat, but under X it looks like our core
1886 * pointer moved. Move the frame pointer to the button press
1887 * location before deciding what to do. */
1888 location = frame_pointer_motion(window->frame, NULL,
1889 button->event_x, button->event_y);
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001890 location = frame_pointer_button(window->frame, NULL,
1891 button_id, button_state);
1892 if (frame_status(window->frame) & FRAME_STATUS_REPAINT)
1893 weston_wm_window_schedule_repaint(window);
1894
1895 if (frame_status(window->frame) & FRAME_STATUS_MOVE) {
Derek Foremane4d6c832015-08-05 14:48:11 -05001896 if (pointer)
Quentin Glidic955cec02016-08-12 10:41:35 +02001897 xwayland_interface->move(window->shsurf, pointer);
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001898 frame_status_clear(window->frame, FRAME_STATUS_MOVE);
1899 }
1900
1901 if (frame_status(window->frame) & FRAME_STATUS_RESIZE) {
Derek Foremane4d6c832015-08-05 14:48:11 -05001902 if (pointer)
Quentin Glidic955cec02016-08-12 10:41:35 +02001903 xwayland_interface->resize(window->shsurf, pointer, location);
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001904 frame_status_clear(window->frame, FRAME_STATUS_RESIZE);
1905 }
1906
1907 if (frame_status(window->frame) & FRAME_STATUS_CLOSE) {
Kristian Høgsberg2cd6da12013-10-13 22:11:07 -07001908 weston_wm_window_close(window, button->time);
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001909 frame_status_clear(window->frame, FRAME_STATUS_CLOSE);
Kristian Høgsbergf96e6c02012-05-22 16:38:53 -04001910 }
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02001911
1912 if (frame_status(window->frame) & FRAME_STATUS_MAXIMIZE) {
1913 window->maximized_horz = !window->maximized_horz;
1914 window->maximized_vert = !window->maximized_vert;
1915 if (weston_wm_window_is_maximized(window)) {
1916 window->saved_width = window->width;
1917 window->saved_height = window->height;
Quentin Glidic955cec02016-08-12 10:41:35 +02001918 xwayland_interface->set_maximized(window->shsurf);
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02001919 } else {
1920 weston_wm_window_set_toplevel(window);
1921 }
1922 frame_status_clear(window->frame, FRAME_STATUS_MAXIMIZE);
1923 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001924}
1925
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001926static void
1927weston_wm_handle_motion(struct weston_wm *wm, xcb_generic_event_t *event)
1928{
1929 xcb_motion_notify_event_t *motion = (xcb_motion_notify_event_t *) event;
1930 struct weston_wm_window *window;
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001931 enum theme_location location;
1932 int cursor;
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001933
Derek Foreman49372142015-04-09 10:51:22 -05001934 if (!wm_lookup_window(wm, motion->event, &window) ||
1935 !window->decorate)
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001936 return;
1937
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001938 location = frame_pointer_motion(window->frame, NULL,
1939 motion->event_x, motion->event_y);
1940 if (frame_status(window->frame) & FRAME_STATUS_REPAINT)
1941 weston_wm_window_schedule_repaint(window);
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001942
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001943 cursor = get_cursor_for_location(location);
Tiago Vignattic1903232012-07-16 12:15:37 -04001944 weston_wm_window_set_cursor(wm, window->frame_id, cursor);
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001945}
1946
1947static void
1948weston_wm_handle_enter(struct weston_wm *wm, xcb_generic_event_t *event)
1949{
1950 xcb_enter_notify_event_t *enter = (xcb_enter_notify_event_t *) event;
1951 struct weston_wm_window *window;
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001952 enum theme_location location;
1953 int cursor;
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001954
Derek Foreman49372142015-04-09 10:51:22 -05001955 if (!wm_lookup_window(wm, enter->event, &window) ||
1956 !window->decorate)
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001957 return;
1958
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001959 location = frame_pointer_enter(window->frame, NULL,
1960 enter->event_x, enter->event_y);
1961 if (frame_status(window->frame) & FRAME_STATUS_REPAINT)
1962 weston_wm_window_schedule_repaint(window);
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001963
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001964 cursor = get_cursor_for_location(location);
Tiago Vignattic1903232012-07-16 12:15:37 -04001965 weston_wm_window_set_cursor(wm, window->frame_id, cursor);
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001966}
1967
1968static void
1969weston_wm_handle_leave(struct weston_wm *wm, xcb_generic_event_t *event)
1970{
1971 xcb_leave_notify_event_t *leave = (xcb_leave_notify_event_t *) event;
1972 struct weston_wm_window *window;
1973
Derek Foreman49372142015-04-09 10:51:22 -05001974 if (!wm_lookup_window(wm, leave->event, &window) ||
1975 !window->decorate)
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001976 return;
1977
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05001978 frame_pointer_leave(window->frame, NULL);
1979 if (frame_status(window->frame) & FRAME_STATUS_REPAINT)
1980 weston_wm_window_schedule_repaint(window);
1981
Tiago Vignattic1903232012-07-16 12:15:37 -04001982 weston_wm_window_set_cursor(wm, window->frame_id, XWM_CURSOR_LEFT_PTR);
Tiago Vignatti236b48d2012-07-16 12:09:19 -04001983}
1984
Giulio Camuffob18f7882015-03-29 14:20:23 +03001985static void
1986weston_wm_handle_focus_in(struct weston_wm *wm, xcb_generic_event_t *event)
1987{
1988 xcb_focus_in_event_t *focus = (xcb_focus_in_event_t *) event;
1989 /* Do not let X clients change the focus behind the compositor's
1990 * back. Reset the focus to the old one if it changed. */
1991 if (!wm->focus_window || focus->event != wm->focus_window->id)
1992 weston_wm_send_focus_window(wm, wm->focus_window);
1993}
1994
Kristian Høgsberg380deee2012-05-21 17:12:41 -04001995static int
1996weston_wm_handle_event(int fd, uint32_t mask, void *data)
1997{
1998 struct weston_wm *wm = data;
1999 xcb_generic_event_t *event;
2000 int count = 0;
2001
2002 while (event = xcb_poll_for_event(wm->conn), event != NULL) {
2003 if (weston_wm_handle_selection_event(wm, event)) {
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002004 free(event);
2005 count++;
2006 continue;
2007 }
2008
Kristian Høgsbergf9cb3b12013-09-04 21:12:26 -07002009 if (weston_wm_handle_dnd_event(wm, event)) {
2010 free(event);
2011 count++;
2012 continue;
2013 }
2014
MoD31700122013-06-11 19:58:55 -05002015 switch (EVENT_TYPE(event)) {
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002016 case XCB_BUTTON_PRESS:
2017 case XCB_BUTTON_RELEASE:
2018 weston_wm_handle_button(wm, event);
2019 break;
Tiago Vignatti236b48d2012-07-16 12:09:19 -04002020 case XCB_ENTER_NOTIFY:
2021 weston_wm_handle_enter(wm, event);
2022 break;
2023 case XCB_LEAVE_NOTIFY:
2024 weston_wm_handle_leave(wm, event);
2025 break;
2026 case XCB_MOTION_NOTIFY:
2027 weston_wm_handle_motion(wm, event);
2028 break;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002029 case XCB_CREATE_NOTIFY:
2030 weston_wm_handle_create_notify(wm, event);
2031 break;
2032 case XCB_MAP_REQUEST:
2033 weston_wm_handle_map_request(wm, event);
2034 break;
2035 case XCB_MAP_NOTIFY:
2036 weston_wm_handle_map_notify(wm, event);
2037 break;
2038 case XCB_UNMAP_NOTIFY:
Kristian Høgsberg194ea542012-05-30 10:05:41 -04002039 weston_wm_handle_unmap_notify(wm, event);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002040 break;
Kristian Høgsberg029539b2012-05-30 11:28:24 -04002041 case XCB_REPARENT_NOTIFY:
2042 weston_wm_handle_reparent_notify(wm, event);
2043 break;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002044 case XCB_CONFIGURE_REQUEST:
2045 weston_wm_handle_configure_request(wm, event);
2046 break;
2047 case XCB_CONFIGURE_NOTIFY:
2048 weston_wm_handle_configure_notify(wm, event);
2049 break;
2050 case XCB_DESTROY_NOTIFY:
2051 weston_wm_handle_destroy_notify(wm, event);
2052 break;
2053 case XCB_MAPPING_NOTIFY:
Kristian Høgsberg082d58c2013-06-18 01:00:27 -04002054 wm_log("XCB_MAPPING_NOTIFY\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002055 break;
2056 case XCB_PROPERTY_NOTIFY:
2057 weston_wm_handle_property_notify(wm, event);
2058 break;
2059 case XCB_CLIENT_MESSAGE:
2060 weston_wm_handle_client_message(wm, event);
2061 break;
Giulio Camuffob18f7882015-03-29 14:20:23 +03002062 case XCB_FOCUS_IN:
2063 weston_wm_handle_focus_in(wm, event);
2064 break;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002065 }
2066
2067 free(event);
2068 count++;
2069 }
2070
Marek Chalupaa1f3f3c2015-08-12 09:55:12 +02002071 if (count != 0)
2072 xcb_flush(wm->conn);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002073
2074 return count;
2075}
2076
2077static void
Benoit Gschwind1a42ca12015-09-25 21:26:04 +02002078weston_wm_set_net_active_window(struct weston_wm *wm, xcb_window_t window) {
2079 xcb_change_property(wm->conn, XCB_PROP_MODE_REPLACE,
2080 wm->screen->root, wm->atom.net_active_window,
2081 wm->atom.window, 32, 1, &window);
2082}
2083
2084static void
Kristian Høgsbergf9187192013-05-02 13:43:24 -04002085weston_wm_get_visual_and_colormap(struct weston_wm *wm)
2086{
2087 xcb_depth_iterator_t d_iter;
2088 xcb_visualtype_iterator_t vt_iter;
2089 xcb_visualtype_t *visualtype;
2090
2091 d_iter = xcb_screen_allowed_depths_iterator(wm->screen);
2092 visualtype = NULL;
2093 while (d_iter.rem > 0) {
2094 if (d_iter.data->depth == 32) {
2095 vt_iter = xcb_depth_visuals_iterator(d_iter.data);
2096 visualtype = vt_iter.data;
2097 break;
2098 }
2099
2100 xcb_depth_next(&d_iter);
2101 }
2102
2103 if (visualtype == NULL) {
2104 weston_log("no 32 bit visualtype\n");
2105 return;
2106 }
2107
2108 wm->visual_id = visualtype->visual_id;
2109 wm->colormap = xcb_generate_id(wm->conn);
2110 xcb_create_colormap(wm->conn, XCB_COLORMAP_ALLOC_NONE,
2111 wm->colormap, wm->screen->root, wm->visual_id);
2112}
2113
2114static void
Tiago Vignatti9c4ff832012-11-30 17:19:57 -02002115weston_wm_get_resources(struct weston_wm *wm)
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002116{
2117
2118#define F(field) offsetof(struct weston_wm, field)
2119
2120 static const struct { const char *name; int offset; } atoms[] = {
2121 { "WM_PROTOCOLS", F(atom.wm_protocols) },
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -07002122 { "WM_NORMAL_HINTS", F(atom.wm_normal_hints) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002123 { "WM_TAKE_FOCUS", F(atom.wm_take_focus) },
2124 { "WM_DELETE_WINDOW", F(atom.wm_delete_window) },
Kristian Høgsberga6d9a5e2012-05-30 12:15:44 -04002125 { "WM_STATE", F(atom.wm_state) },
Kristian Høgsberg670b5d32012-06-04 11:00:40 -04002126 { "WM_S0", F(atom.wm_s0) },
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +03002127 { "WM_CLIENT_MACHINE", F(atom.wm_client_machine) },
Kristian Høgsberg69981d92013-08-21 22:14:58 -07002128 { "_NET_WM_CM_S0", F(atom.net_wm_cm_s0) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002129 { "_NET_WM_NAME", F(atom.net_wm_name) },
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +03002130 { "_NET_WM_PID", F(atom.net_wm_pid) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002131 { "_NET_WM_ICON", F(atom.net_wm_icon) },
2132 { "_NET_WM_STATE", F(atom.net_wm_state) },
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02002133 { "_NET_WM_STATE_MAXIMIZED_VERT", F(atom.net_wm_state_maximized_vert) },
2134 { "_NET_WM_STATE_MAXIMIZED_HORZ", F(atom.net_wm_state_maximized_horz) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002135 { "_NET_WM_STATE_FULLSCREEN", F(atom.net_wm_state_fullscreen) },
2136 { "_NET_WM_USER_TIME", F(atom.net_wm_user_time) },
2137 { "_NET_WM_ICON_NAME", F(atom.net_wm_icon_name) },
Giulio Camuffoe90ea442014-12-13 18:06:34 +02002138 { "_NET_WM_DESKTOP", F(atom.net_wm_desktop) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002139 { "_NET_WM_WINDOW_TYPE", F(atom.net_wm_window_type) },
2140
2141 { "_NET_WM_WINDOW_TYPE_DESKTOP", F(atom.net_wm_window_type_desktop) },
2142 { "_NET_WM_WINDOW_TYPE_DOCK", F(atom.net_wm_window_type_dock) },
2143 { "_NET_WM_WINDOW_TYPE_TOOLBAR", F(atom.net_wm_window_type_toolbar) },
2144 { "_NET_WM_WINDOW_TYPE_MENU", F(atom.net_wm_window_type_menu) },
2145 { "_NET_WM_WINDOW_TYPE_UTILITY", F(atom.net_wm_window_type_utility) },
2146 { "_NET_WM_WINDOW_TYPE_SPLASH", F(atom.net_wm_window_type_splash) },
2147 { "_NET_WM_WINDOW_TYPE_DIALOG", F(atom.net_wm_window_type_dialog) },
Tiago Vignattibf1e8662012-06-12 14:07:49 +03002148 { "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", F(atom.net_wm_window_type_dropdown) },
2149 { "_NET_WM_WINDOW_TYPE_POPUP_MENU", F(atom.net_wm_window_type_popup) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002150 { "_NET_WM_WINDOW_TYPE_TOOLTIP", F(atom.net_wm_window_type_tooltip) },
2151 { "_NET_WM_WINDOW_TYPE_NOTIFICATION", F(atom.net_wm_window_type_notification) },
2152 { "_NET_WM_WINDOW_TYPE_COMBO", F(atom.net_wm_window_type_combo) },
2153 { "_NET_WM_WINDOW_TYPE_DND", F(atom.net_wm_window_type_dnd) },
2154 { "_NET_WM_WINDOW_TYPE_NORMAL", F(atom.net_wm_window_type_normal) },
2155
2156 { "_NET_WM_MOVERESIZE", F(atom.net_wm_moveresize) },
2157 { "_NET_SUPPORTING_WM_CHECK",
2158 F(atom.net_supporting_wm_check) },
2159 { "_NET_SUPPORTED", F(atom.net_supported) },
Benoit Gschwind1a42ca12015-09-25 21:26:04 +02002160 { "_NET_ACTIVE_WINDOW", F(atom.net_active_window) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002161 { "_MOTIF_WM_HINTS", F(atom.motif_wm_hints) },
2162 { "CLIPBOARD", F(atom.clipboard) },
Kristian Høgsbergcba022a2012-06-04 10:11:45 -04002163 { "CLIPBOARD_MANAGER", F(atom.clipboard_manager) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002164 { "TARGETS", F(atom.targets) },
2165 { "UTF8_STRING", F(atom.utf8_string) },
2166 { "_WL_SELECTION", F(atom.wl_selection) },
2167 { "INCR", F(atom.incr) },
2168 { "TIMESTAMP", F(atom.timestamp) },
2169 { "MULTIPLE", F(atom.multiple) },
2170 { "UTF8_STRING" , F(atom.utf8_string) },
2171 { "COMPOUND_TEXT", F(atom.compound_text) },
2172 { "TEXT", F(atom.text) },
2173 { "STRING", F(atom.string) },
Benoit Gschwind1a42ca12015-09-25 21:26:04 +02002174 { "WINDOW", F(atom.window) },
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002175 { "text/plain;charset=utf-8", F(atom.text_plain_utf8) },
2176 { "text/plain", F(atom.text_plain) },
Kristian Høgsbergf9cb3b12013-09-04 21:12:26 -07002177 { "XdndSelection", F(atom.xdnd_selection) },
2178 { "XdndAware", F(atom.xdnd_aware) },
2179 { "XdndEnter", F(atom.xdnd_enter) },
2180 { "XdndLeave", F(atom.xdnd_leave) },
2181 { "XdndDrop", F(atom.xdnd_drop) },
2182 { "XdndStatus", F(atom.xdnd_status) },
2183 { "XdndFinished", F(atom.xdnd_finished) },
2184 { "XdndTypeList", F(atom.xdnd_type_list) },
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002185 { "XdndActionCopy", F(atom.xdnd_action_copy) },
2186 { "WL_SURFACE_ID", F(atom.wl_surface_id) }
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002187 };
2188#undef F
2189
2190 xcb_xfixes_query_version_cookie_t xfixes_cookie;
2191 xcb_xfixes_query_version_reply_t *xfixes_reply;
2192 xcb_intern_atom_cookie_t cookies[ARRAY_LENGTH(atoms)];
2193 xcb_intern_atom_reply_t *reply;
2194 xcb_render_query_pict_formats_reply_t *formats_reply;
2195 xcb_render_query_pict_formats_cookie_t formats_cookie;
2196 xcb_render_pictforminfo_t *formats;
2197 uint32_t i;
2198
2199 xcb_prefetch_extension_data (wm->conn, &xcb_xfixes_id);
Kristian Høgsbergbcfd07b2013-10-11 16:48:19 -07002200 xcb_prefetch_extension_data (wm->conn, &xcb_composite_id);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002201
2202 formats_cookie = xcb_render_query_pict_formats(wm->conn);
2203
2204 for (i = 0; i < ARRAY_LENGTH(atoms); i++)
2205 cookies[i] = xcb_intern_atom (wm->conn, 0,
2206 strlen(atoms[i].name),
2207 atoms[i].name);
2208
2209 for (i = 0; i < ARRAY_LENGTH(atoms); i++) {
2210 reply = xcb_intern_atom_reply (wm->conn, cookies[i], NULL);
2211 *(xcb_atom_t *) ((char *) wm + atoms[i].offset) = reply->atom;
2212 free(reply);
2213 }
2214
2215 wm->xfixes = xcb_get_extension_data(wm->conn, &xcb_xfixes_id);
2216 if (!wm->xfixes || !wm->xfixes->present)
Martin Minarik6d118362012-06-07 18:01:59 +02002217 weston_log("xfixes not available\n");
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002218
2219 xfixes_cookie = xcb_xfixes_query_version(wm->conn,
2220 XCB_XFIXES_MAJOR_VERSION,
2221 XCB_XFIXES_MINOR_VERSION);
2222 xfixes_reply = xcb_xfixes_query_version_reply(wm->conn,
2223 xfixes_cookie, NULL);
2224
Martin Minarik6d118362012-06-07 18:01:59 +02002225 weston_log("xfixes version: %d.%d\n",
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002226 xfixes_reply->major_version, xfixes_reply->minor_version);
2227
2228 free(xfixes_reply);
2229
2230 formats_reply = xcb_render_query_pict_formats_reply(wm->conn,
2231 formats_cookie, 0);
2232 if (formats_reply == NULL)
2233 return;
2234
2235 formats = xcb_render_query_pict_formats_formats(formats_reply);
Kristian Høgsberge89cef32012-07-16 11:57:08 -04002236 for (i = 0; i < formats_reply->num_formats; i++) {
2237 if (formats[i].direct.red_mask != 0xff &&
2238 formats[i].direct.red_shift != 16)
2239 continue;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002240 if (formats[i].type == XCB_RENDER_PICT_TYPE_DIRECT &&
2241 formats[i].depth == 24)
Kristian Høgsberge89cef32012-07-16 11:57:08 -04002242 wm->format_rgb = formats[i];
2243 if (formats[i].type == XCB_RENDER_PICT_TYPE_DIRECT &&
2244 formats[i].depth == 32 &&
2245 formats[i].direct.alpha_mask == 0xff &&
2246 formats[i].direct.alpha_shift == 24)
2247 wm->format_rgba = formats[i];
2248 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002249
2250 free(formats_reply);
2251}
2252
2253static void
2254weston_wm_create_wm_window(struct weston_wm *wm)
2255{
2256 static const char name[] = "Weston WM";
2257
2258 wm->wm_window = xcb_generate_id(wm->conn);
2259 xcb_create_window(wm->conn,
2260 XCB_COPY_FROM_PARENT,
2261 wm->wm_window,
2262 wm->screen->root,
2263 0, 0,
2264 10, 10,
2265 0,
2266 XCB_WINDOW_CLASS_INPUT_OUTPUT,
2267 wm->screen->root_visual,
2268 0, NULL);
2269
2270 xcb_change_property(wm->conn,
2271 XCB_PROP_MODE_REPLACE,
2272 wm->wm_window,
2273 wm->atom.net_supporting_wm_check,
2274 XCB_ATOM_WINDOW,
2275 32, /* format */
2276 1, &wm->wm_window);
2277
2278 xcb_change_property(wm->conn,
2279 XCB_PROP_MODE_REPLACE,
2280 wm->wm_window,
2281 wm->atom.net_wm_name,
2282 wm->atom.utf8_string,
2283 8, /* format */
2284 strlen(name), name);
2285
2286 xcb_change_property(wm->conn,
2287 XCB_PROP_MODE_REPLACE,
2288 wm->screen->root,
2289 wm->atom.net_supporting_wm_check,
2290 XCB_ATOM_WINDOW,
2291 32, /* format */
2292 1, &wm->wm_window);
2293
Abdur Rehmanb8b150b2017-01-01 19:46:46 +05002294 /* Claim the WM_S0 selection even though we don't support
Kristian Høgsberg670b5d32012-06-04 11:00:40 -04002295 * the --replace functionality. */
2296 xcb_set_selection_owner(wm->conn,
2297 wm->wm_window,
2298 wm->atom.wm_s0,
2299 XCB_TIME_CURRENT_TIME);
Kristian Høgsberg69981d92013-08-21 22:14:58 -07002300
2301 xcb_set_selection_owner(wm->conn,
2302 wm->wm_window,
2303 wm->atom.net_wm_cm_s0,
2304 XCB_TIME_CURRENT_TIME);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002305}
2306
2307struct weston_wm *
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002308weston_wm_create(struct weston_xserver *wxs, int fd)
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002309{
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002310 struct weston_wm *wm;
2311 struct wl_event_loop *loop;
2312 xcb_screen_iterator_t s;
Kristian Høgsberg4dec0112012-06-03 09:18:06 -04002313 uint32_t values[1];
Benoit Gschwind1a42ca12015-09-25 21:26:04 +02002314 xcb_atom_t supported[6];
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002315
Peter Huttererf3d62272013-08-08 11:57:05 +10002316 wm = zalloc(sizeof *wm);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002317 if (wm == NULL)
2318 return NULL;
2319
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002320 wm->server = wxs;
2321 wm->window_hash = hash_table_create();
2322 if (wm->window_hash == NULL) {
2323 free(wm);
2324 return NULL;
2325 }
2326
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002327 /* xcb_connect_to_fd takes ownership of the fd. */
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002328 wm->conn = xcb_connect_to_fd(fd, NULL);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002329 if (xcb_connection_has_error(wm->conn)) {
Martin Minarik6d118362012-06-07 18:01:59 +02002330 weston_log("xcb_connect_to_fd failed\n");
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002331 close(fd);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002332 hash_table_destroy(wm->window_hash);
2333 free(wm);
2334 return NULL;
2335 }
2336
2337 s = xcb_setup_roots_iterator(xcb_get_setup(wm->conn));
2338 wm->screen = s.data;
2339
2340 loop = wl_display_get_event_loop(wxs->wl_display);
2341 wm->source =
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002342 wl_event_loop_add_fd(loop, fd,
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002343 WL_EVENT_READABLE,
2344 weston_wm_handle_event, wm);
2345 wl_event_source_check(wm->source);
2346
Tiago Vignatti9c4ff832012-11-30 17:19:57 -02002347 weston_wm_get_resources(wm);
Kristian Høgsbergf9187192013-05-02 13:43:24 -04002348 weston_wm_get_visual_and_colormap(wm);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002349
2350 values[0] =
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002351 XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
2352 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT |
2353 XCB_EVENT_MASK_PROPERTY_CHANGE;
2354 xcb_change_window_attributes(wm->conn, wm->screen->root,
2355 XCB_CW_EVENT_MASK, values);
Kristian Høgsbergbcfd07b2013-10-11 16:48:19 -07002356
2357 xcb_composite_redirect_subwindows(wm->conn, wm->screen->root,
2358 XCB_COMPOSITE_REDIRECT_MANUAL);
2359
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002360 wm->theme = theme_create();
2361
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002362 supported[0] = wm->atom.net_wm_moveresize;
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05002363 supported[1] = wm->atom.net_wm_state;
2364 supported[2] = wm->atom.net_wm_state_fullscreen;
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02002365 supported[3] = wm->atom.net_wm_state_maximized_vert;
2366 supported[4] = wm->atom.net_wm_state_maximized_horz;
Benoit Gschwind1a42ca12015-09-25 21:26:04 +02002367 supported[5] = wm->atom.net_active_window;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002368 xcb_change_property(wm->conn,
2369 XCB_PROP_MODE_REPLACE,
2370 wm->screen->root,
2371 wm->atom.net_supported,
2372 XCB_ATOM_ATOM,
2373 32, /* format */
2374 ARRAY_LENGTH(supported), supported);
2375
Benoit Gschwind1a42ca12015-09-25 21:26:04 +02002376 weston_wm_set_net_active_window(wm, XCB_WINDOW_NONE);
2377
Kristian Høgsberg4dec0112012-06-03 09:18:06 -04002378 weston_wm_selection_init(wm);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002379
Kristian Høgsbergf9cb3b12013-09-04 21:12:26 -07002380 weston_wm_dnd_init(wm);
2381
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002382 xcb_flush(wm->conn);
2383
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002384 wm->create_surface_listener.notify = weston_wm_create_surface;
2385 wl_signal_add(&wxs->compositor->create_surface_signal,
2386 &wm->create_surface_listener);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002387 wm->activate_listener.notify = weston_wm_window_activate;
2388 wl_signal_add(&wxs->compositor->activate_signal,
2389 &wm->activate_listener);
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +03002390 wm->kill_listener.notify = weston_wm_kill_client;
2391 wl_signal_add(&wxs->compositor->kill_signal,
2392 &wm->kill_listener);
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002393 wl_list_init(&wm->unpaired_window_list);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002394
Tiago Vignatti236b48d2012-07-16 12:09:19 -04002395 weston_wm_create_cursors(wm);
Tiago Vignattic1903232012-07-16 12:15:37 -04002396 weston_wm_window_set_cursor(wm, wm->screen->root, XWM_CURSOR_LEFT_PTR);
Tiago Vignatti236b48d2012-07-16 12:09:19 -04002397
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002398 /* Create wm window and take WM_S0 selection last, which
2399 * signals to Xwayland that we're done with setup. */
2400 weston_wm_create_wm_window(wm);
2401
2402 weston_log("created wm, root %d\n", wm->screen->root);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002403
2404 return wm;
2405}
2406
2407void
2408weston_wm_destroy(struct weston_wm *wm)
2409{
2410 /* FIXME: Free windows in hash. */
2411 hash_table_destroy(wm->window_hash);
Tiago Vignatti236b48d2012-07-16 12:09:19 -04002412 weston_wm_destroy_cursors(wm);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002413 xcb_disconnect(wm->conn);
2414 wl_event_source_remove(wm->source);
2415 wl_list_remove(&wm->selection_listener.link);
2416 wl_list_remove(&wm->activate_listener.link);
Tiago Vignatti0d20d7c2012-09-27 17:48:37 +03002417 wl_list_remove(&wm->kill_listener.link);
Derek Foremanf10e06c2015-02-03 11:05:10 -06002418 wl_list_remove(&wm->create_surface_listener.link);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002419
2420 free(wm);
2421}
2422
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002423static struct weston_wm_window *
2424get_wm_window(struct weston_surface *surface)
2425{
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002426 struct wl_listener *listener;
2427
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002428 listener = wl_signal_get(&surface->destroy_signal, surface_destroy);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002429 if (listener)
2430 return container_of(listener, struct weston_wm_window,
2431 surface_destroy_listener);
2432
2433 return NULL;
2434}
2435
Quentin Glidic955cec02016-08-12 10:41:35 +02002436static bool
2437is_wm_window(struct weston_surface *surface)
2438{
2439 return get_wm_window(surface) != NULL;
2440}
2441
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002442static void
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002443weston_wm_window_configure(void *data)
2444{
2445 struct weston_wm_window *window = data;
2446 struct weston_wm *wm = window->wm;
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05002447 uint32_t values[4];
2448 int x, y, width, height;
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002449
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05002450 weston_wm_window_get_child_position(window, &x, &y);
2451 values[0] = x;
2452 values[1] = y;
2453 values[2] = window->width;
2454 values[3] = window->height;
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002455 xcb_configure_window(wm->conn,
2456 window->id,
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05002457 XCB_CONFIG_WINDOW_X |
2458 XCB_CONFIG_WINDOW_Y |
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002459 XCB_CONFIG_WINDOW_WIDTH |
2460 XCB_CONFIG_WINDOW_HEIGHT,
2461 values);
2462
2463 weston_wm_window_get_frame_size(window, &width, &height);
2464 values[0] = width;
2465 values[1] = height;
2466 xcb_configure_window(wm->conn,
2467 window->frame_id,
2468 XCB_CONFIG_WINDOW_WIDTH |
2469 XCB_CONFIG_WINDOW_HEIGHT,
2470 values);
2471
2472 window->configure_source = NULL;
2473
2474 weston_wm_window_schedule_repaint(window);
2475}
2476
2477static void
Jasper St. Pierreac985be2014-04-28 11:19:28 -04002478send_configure(struct weston_surface *surface, int32_t width, int32_t height)
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002479{
2480 struct weston_wm_window *window = get_wm_window(surface);
2481 struct weston_wm *wm = window->wm;
2482 struct theme *t = window->wm->theme;
Kristian Høgsbergfa514b42013-07-08 15:00:25 -04002483 int vborder, hborder;
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002484
Marek Chalupae9fe4672014-10-29 13:44:44 +01002485 if (window->decorate && !window->fullscreen) {
Jasper St. Pierre8ffd38b2014-08-27 09:38:33 -04002486 hborder = 2 * t->width;
2487 vborder = t->titlebar_height + t->width;
2488 } else {
Kristian Høgsbergfa514b42013-07-08 15:00:25 -04002489 hborder = 0;
2490 vborder = 0;
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002491 }
2492
Kristian Høgsbergfa514b42013-07-08 15:00:25 -04002493 if (width > hborder)
2494 window->width = width - hborder;
2495 else
2496 window->width = 1;
2497
2498 if (height > vborder)
2499 window->height = height - vborder;
2500 else
2501 window->height = 1;
2502
Jason Ekstrandd14c4ca2013-10-13 19:08:41 -05002503 if (window->frame)
2504 frame_resize_inside(window->frame, window->width, window->height);
2505
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002506 if (window->configure_source)
2507 return;
2508
2509 window->configure_source =
2510 wl_event_loop_add_idle(wm->server->loop,
2511 weston_wm_window_configure, window);
2512}
2513
Giulio Camuffof05d18f2015-12-11 20:57:05 +02002514static void
2515send_position(struct weston_surface *surface, int32_t x, int32_t y)
2516{
2517 struct weston_wm_window *window = get_wm_window(surface);
2518 struct weston_wm *wm;
2519 uint32_t mask, values[2];
2520
2521 if (!window || !window->wm)
2522 return;
2523
2524 wm = window->wm;
2525 /* We use pos_dirty to tell whether a configure message is in flight.
2526 * This is needed in case we send two configure events in a very
2527 * short time, since window->x/y is set in after a roundtrip, hence
2528 * we cannot just check if the current x and y are different. */
2529 if (window->x != x || window->y != y || window->pos_dirty) {
2530 window->pos_dirty = true;
2531 values[0] = x;
2532 values[1] = y;
2533 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y;
2534
2535 xcb_configure_window(wm->conn, window->frame_id, mask, values);
2536 xcb_flush(wm->conn);
2537 }
2538}
2539
Quentin Glidic955cec02016-08-12 10:41:35 +02002540static const struct weston_xwayland_client_interface shell_client = {
Giulio Camuffof05d18f2015-12-11 20:57:05 +02002541 send_configure,
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002542};
2543
Kristian Høgsberg59f44c12013-08-31 00:08:27 -07002544static int
2545legacy_fullscreen(struct weston_wm *wm,
2546 struct weston_wm_window *window,
2547 struct weston_output **output_ret)
2548{
2549 struct weston_compositor *compositor = wm->server->compositor;
2550 struct weston_output *output;
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -07002551 uint32_t minmax = PMinSize | PMaxSize;
2552 int matching_size;
Kristian Høgsberg59f44c12013-08-31 00:08:27 -07002553
2554 /* Heuristics for detecting legacy fullscreen windows... */
2555
2556 wl_list_for_each(output, &compositor->output_list, link) {
2557 if (output->x == window->x &&
2558 output->y == window->y &&
2559 output->width == window->width &&
2560 output->height == window->height &&
2561 window->override_redirect) {
2562 *output_ret = output;
2563 return 1;
2564 }
Kristian Høgsberg1a7a57f2013-08-31 00:12:25 -07002565
2566 matching_size = 0;
2567 if ((window->size_hints.flags & (USSize |PSize)) &&
2568 window->size_hints.width == output->width &&
2569 window->size_hints.height == output->height)
2570 matching_size = 1;
2571 if ((window->size_hints.flags & minmax) == minmax &&
2572 window->size_hints.min_width == output->width &&
2573 window->size_hints.min_height == output->height &&
2574 window->size_hints.max_width == output->width &&
2575 window->size_hints.max_height == output->height)
2576 matching_size = 1;
2577
2578 if (matching_size && !window->decorate &&
2579 (window->size_hints.flags & (USPosition | PPosition)) &&
2580 window->size_hints.x == output->x &&
2581 window->size_hints.y == output->y) {
2582 *output_ret = output;
2583 return 1;
2584 }
Kristian Høgsberg59f44c12013-08-31 00:08:27 -07002585 }
2586
2587 return 0;
2588}
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002589
Giulio Camuffo836b9c72015-01-24 17:54:21 +02002590static bool
2591weston_wm_window_type_inactive(struct weston_wm_window *window)
2592{
2593 struct weston_wm *wm = window->wm;
2594
2595 return window->type == wm->atom.net_wm_window_type_tooltip ||
2596 window->type == wm->atom.net_wm_window_type_dropdown ||
2597 window->type == wm->atom.net_wm_window_type_dnd ||
2598 window->type == wm->atom.net_wm_window_type_combo ||
Giulio Camuffo84787ea2015-04-29 19:00:48 +03002599 window->type == wm->atom.net_wm_window_type_popup ||
2600 window->type == wm->atom.net_wm_window_type_utility;
Giulio Camuffo836b9c72015-01-24 17:54:21 +02002601}
2602
Kristian Høgsberga61ca062012-05-22 16:05:52 -04002603static void
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002604xserver_map_shell_surface(struct weston_wm_window *window,
2605 struct weston_surface *surface)
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002606{
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002607 struct weston_wm *wm = window->wm;
Quentin Glidic955cec02016-08-12 10:41:35 +02002608 struct weston_desktop_xwayland *xwayland =
2609 wm->server->compositor->xwayland;
2610 const struct weston_desktop_xwayland_interface *xwayland_interface =
2611 wm->server->compositor->xwayland_interface;
Kristian Høgsberg9f7e3312014-01-02 22:40:37 -08002612 struct weston_wm_window *parent;
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002613
Kristian Høgsberg757d8af2014-03-17 22:33:29 -07002614 weston_wm_window_read_properties(window);
2615
2616 /* A weston_wm_window may have many different surfaces assigned
2617 * throughout its life, so we must make sure to remove the listener
2618 * from the old surface signal list. */
2619 if (window->surface)
2620 wl_list_remove(&window->surface_destroy_listener.link);
2621
2622 window->surface = surface;
2623 window->surface_destroy_listener.notify = surface_destroy;
2624 wl_signal_add(&window->surface->destroy_signal,
2625 &window->surface_destroy_listener);
2626
2627 weston_wm_window_schedule_repaint(window);
2628
Quentin Glidic955cec02016-08-12 10:41:35 +02002629 if (!xwayland_interface)
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002630 return;
2631
Quentin Glidic2edc3d52016-08-12 10:41:33 +02002632 if (window->surface->committed) {
Pekka Paalanen50b67472014-10-01 15:02:41 +03002633 weston_log("warning, unexpected in %s: "
2634 "surface's configure hook is already set.\n",
2635 __func__);
2636 return;
2637 }
2638
Murray Calavera883ac022015-06-06 13:02:22 +00002639 window->shsurf =
Quentin Glidic955cec02016-08-12 10:41:35 +02002640 xwayland_interface->create_surface(xwayland,
2641 window->surface,
2642 &shell_client);
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002643
Pekka Paalanena04eacc2016-11-28 16:42:25 +02002644 wm_log("XWM: map shell surface, win %d, xwayland surface %p\n",
2645 window->id, window->shsurf);
2646
Giulio Camuffo62942ad2013-09-11 18:20:47 +02002647 if (window->name)
Quentin Glidic955cec02016-08-12 10:41:35 +02002648 xwayland_interface->set_title(window->shsurf, window->name);
Giulio Camuffoa8e9b412015-01-27 19:10:37 +02002649 if (window->pid > 0)
Quentin Glidic955cec02016-08-12 10:41:35 +02002650 xwayland_interface->set_pid(window->shsurf, window->pid);
Giulio Camuffo62942ad2013-09-11 18:20:47 +02002651
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05002652 if (window->fullscreen) {
2653 window->saved_width = window->width;
2654 window->saved_height = window->height;
Pekka Paalanen505237e2016-12-01 15:41:11 +02002655 xwayland_interface->set_fullscreen(window->shsurf,
2656 window->legacy_fullscreen_output.output);
Kristian Høgsbergb810eb52013-02-12 20:07:05 -05002657 return;
Kristian Høgsberg9f7e3312014-01-02 22:40:37 -08002658 } else if (window->override_redirect) {
Quentin Glidic955cec02016-08-12 10:41:35 +02002659 xwayland_interface->set_xwayland(window->shsurf,
2660 window->x, window->y);
Axel Davye4450f92014-01-12 15:06:05 +01002661 } else if (window->transient_for && window->transient_for->surface) {
Kristian Høgsberg9f7e3312014-01-02 22:40:37 -08002662 parent = window->transient_for;
Quentin Glidic955cec02016-08-12 10:41:35 +02002663 if (weston_wm_window_type_inactive(window)) {
2664 xwayland_interface->set_transient(window->shsurf,
2665 parent->surface,
2666 window->x - parent->x,
2667 window->y - parent->y);
2668 } else {
2669 xwayland_interface->set_toplevel(window->shsurf);
2670 xwayland_interface->set_parent(window->shsurf,
2671 parent->surface);
2672 }
Giulio Camuffo6b4b2412015-01-29 19:06:49 +02002673 } else if (weston_wm_window_is_maximized(window)) {
Quentin Glidic955cec02016-08-12 10:41:35 +02002674 xwayland_interface->set_maximized(window->shsurf);
Kristian Høgsberg9f7e3312014-01-02 22:40:37 -08002675 } else {
Giulio Camuffo836b9c72015-01-24 17:54:21 +02002676 if (weston_wm_window_type_inactive(window)) {
Quentin Glidic955cec02016-08-12 10:41:35 +02002677 xwayland_interface->set_xwayland(window->shsurf,
2678 window->x,
2679 window->y);
Giulio Camuffo836b9c72015-01-24 17:54:21 +02002680 } else {
Quentin Glidic955cec02016-08-12 10:41:35 +02002681 xwayland_interface->set_toplevel(window->shsurf);
Giulio Camuffo836b9c72015-01-24 17:54:21 +02002682 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002683 }
Kristian Høgsberg380deee2012-05-21 17:12:41 -04002684}
Quentin Glidic955cec02016-08-12 10:41:35 +02002685
2686const struct weston_xwayland_surface_api surface_api = {
2687 is_wm_window,
2688 send_position,
2689};