2 * Copyright © 2011 Intel Corporation
4 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
28 #include <sys/socket.h>
34 #include <X11/Xcursor/Xcursor.h>
35 #include <linux/input.h>
39 #include "cairo-util.h"
40 #include "compositor.h"
43 struct wm_size_hints {
46 int32_t width, height; /* should set so old wm's don't mess up */
47 int32_t min_width, min_height;
48 int32_t max_width, max_height;
49 int32_t width_inc, height_inc;
53 } min_aspect, max_aspect;
54 int32_t base_width, base_height;
58 #define USPosition (1L << 0)
59 #define USSize (1L << 1)
60 #define PPosition (1L << 2)
61 #define PSize (1L << 3)
62 #define PMinSize (1L << 4)
63 #define PMaxSize (1L << 5)
64 #define PResizeInc (1L << 6)
65 #define PAspect (1L << 7)
66 #define PBaseSize (1L << 8)
67 #define PWinGravity (1L << 9)
69 struct motif_wm_hints {
77 #define MWM_HINTS_FUNCTIONS (1L << 0)
78 #define MWM_HINTS_DECORATIONS (1L << 1)
79 #define MWM_HINTS_INPUT_MODE (1L << 2)
80 #define MWM_HINTS_STATUS (1L << 3)
82 #define MWM_FUNC_ALL (1L << 0)
83 #define MWM_FUNC_RESIZE (1L << 1)
84 #define MWM_FUNC_MOVE (1L << 2)
85 #define MWM_FUNC_MINIMIZE (1L << 3)
86 #define MWM_FUNC_MAXIMIZE (1L << 4)
87 #define MWM_FUNC_CLOSE (1L << 5)
89 #define MWM_DECOR_ALL (1L << 0)
90 #define MWM_DECOR_BORDER (1L << 1)
91 #define MWM_DECOR_RESIZEH (1L << 2)
92 #define MWM_DECOR_TITLE (1L << 3)
93 #define MWM_DECOR_MENU (1L << 4)
94 #define MWM_DECOR_MINIMIZE (1L << 5)
95 #define MWM_DECOR_MAXIMIZE (1L << 6)
97 #define MWM_INPUT_MODELESS 0
98 #define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1
99 #define MWM_INPUT_SYSTEM_MODAL 2
100 #define MWM_INPUT_FULL_APPLICATION_MODAL 3
101 #define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL
103 #define MWM_TEAROFF_WINDOW (1L<<0)
105 #define _NET_WM_MOVERESIZE_SIZE_TOPLEFT 0
106 #define _NET_WM_MOVERESIZE_SIZE_TOP 1
107 #define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT 2
108 #define _NET_WM_MOVERESIZE_SIZE_RIGHT 3
109 #define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT 4
110 #define _NET_WM_MOVERESIZE_SIZE_BOTTOM 5
111 #define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT 6
112 #define _NET_WM_MOVERESIZE_SIZE_LEFT 7
113 #define _NET_WM_MOVERESIZE_MOVE 8 /* movement only */
114 #define _NET_WM_MOVERESIZE_SIZE_KEYBOARD 9 /* size via keyboard */
115 #define _NET_WM_MOVERESIZE_MOVE_KEYBOARD 10 /* move via keyboard */
116 #define _NET_WM_MOVERESIZE_CANCEL 11 /* cancel operation */
118 struct weston_wm_window {
119 struct weston_wm *wm;
121 xcb_window_t frame_id;
123 cairo_surface_t *cairo_surface;
125 struct weston_surface *surface;
126 struct shell_surface *shsurf;
127 struct weston_view *view;
128 struct wl_listener surface_destroy_listener;
129 struct wl_event_source *repaint_source;
130 struct wl_event_source *configure_source;
131 int properties_dirty;
136 struct weston_wm_window *transient_for;
141 int saved_width, saved_height;
143 int override_redirect;
147 struct wm_size_hints size_hints;
148 struct motif_wm_hints motif_hints;
152 static struct weston_wm_window *
153 get_wm_window(struct weston_surface *surface);
156 weston_wm_window_schedule_repaint(struct weston_wm_window *window);
159 xserver_map_shell_surface(struct weston_wm_window *window,
160 struct weston_surface *surface);
162 static int __attribute__ ((format (printf, 1, 2)))
163 wm_log(const char *fmt, ...)
170 l = weston_vlog(fmt, argp);
179 static int __attribute__ ((format (printf, 1, 2)))
180 wm_log_continue(const char *fmt, ...)
187 l = weston_vlog_continue(fmt, argp);
198 get_atom_name(xcb_connection_t *c, xcb_atom_t atom)
200 xcb_get_atom_name_cookie_t cookie;
201 xcb_get_atom_name_reply_t *reply;
202 xcb_generic_error_t *e;
203 static char buffer[64];
205 if (atom == XCB_ATOM_NONE)
208 cookie = xcb_get_atom_name (c, atom);
209 reply = xcb_get_atom_name_reply (c, cookie, &e);
212 snprintf(buffer, sizeof buffer, "%.*s",
213 xcb_get_atom_name_name_length (reply),
214 xcb_get_atom_name_name (reply));
216 snprintf(buffer, sizeof buffer, "(atom %u)", atom);
225 xcb_cursor_image_load_cursor(struct weston_wm *wm, const XcursorImage *img)
227 xcb_connection_t *c = wm->conn;
228 xcb_screen_iterator_t s = xcb_setup_roots_iterator(xcb_get_setup(c));
229 xcb_screen_t *screen = s.data;
232 xcb_render_picture_t pic;
234 int stride = img->width * 4;
236 pix = xcb_generate_id(c);
237 xcb_create_pixmap(c, 32, pix, screen->root, img->width, img->height);
239 pic = xcb_generate_id(c);
240 xcb_render_create_picture(c, pic, pix, wm->format_rgba.id, 0, 0);
242 gc = xcb_generate_id(c);
243 xcb_create_gc(c, gc, pix, 0, 0);
245 xcb_put_image(c, XCB_IMAGE_FORMAT_Z_PIXMAP, pix, gc,
246 img->width, img->height, 0, 0, 0, 32,
247 stride * img->height, (uint8_t *) img->pixels);
250 cursor = xcb_generate_id(c);
251 xcb_render_create_cursor(c, cursor, pic, img->xhot, img->yhot);
253 xcb_render_free_picture(c, pic);
254 xcb_free_pixmap(c, pix);
260 xcb_cursor_images_load_cursor(struct weston_wm *wm, const XcursorImages *images)
262 /* TODO: treat animated cursors as well */
263 if (images->nimage != 1)
266 return xcb_cursor_image_load_cursor(wm, images->images[0]);
270 xcb_cursor_library_load_cursor(struct weston_wm *wm, const char *file)
273 XcursorImages *images;
280 v = getenv ("XCURSOR_SIZE");
287 images = XcursorLibraryLoadImages (file, NULL, size);
291 cursor = xcb_cursor_images_load_cursor (wm, images);
292 XcursorImagesDestroy (images);
298 dump_property(struct weston_wm *wm,
299 xcb_atom_t property, xcb_get_property_reply_t *reply)
302 const char *text_value, *name;
303 xcb_atom_t *atom_value;
307 width = wm_log_continue("%s: ", get_atom_name(wm->conn, property));
309 wm_log_continue("(no reply)\n");
313 width += wm_log_continue("%s/%d, length %d (value_len %d): ",
314 get_atom_name(wm->conn, reply->type),
316 xcb_get_property_value_length(reply),
319 if (reply->type == wm->atom.incr) {
320 incr_value = xcb_get_property_value(reply);
321 wm_log_continue("%d\n", *incr_value);
322 } else if (reply->type == wm->atom.utf8_string ||
323 reply->type == wm->atom.string) {
324 text_value = xcb_get_property_value(reply);
325 if (reply->value_len > 40)
328 len = reply->value_len;
329 wm_log_continue("\"%.*s\"\n", len, text_value);
330 } else if (reply->type == XCB_ATOM_ATOM) {
331 atom_value = xcb_get_property_value(reply);
332 for (i = 0; i < reply->value_len; i++) {
333 name = get_atom_name(wm->conn, atom_value[i]);
334 if (width + strlen(name) + 2 > 78) {
335 wm_log_continue("\n ");
338 width += wm_log_continue(", ");
341 width += wm_log_continue("%s", name);
343 wm_log_continue("\n");
345 wm_log_continue("huh?\n");
350 read_and_dump_property(struct weston_wm *wm,
351 xcb_window_t window, xcb_atom_t property)
353 xcb_get_property_reply_t *reply;
354 xcb_get_property_cookie_t cookie;
356 cookie = xcb_get_property(wm->conn, 0, window,
357 property, XCB_ATOM_ANY, 0, 2048);
358 reply = xcb_get_property_reply(wm->conn, cookie, NULL);
360 dump_property(wm, property, reply);
365 /* We reuse some predefined, but otherwise useles atoms */
366 #define TYPE_WM_PROTOCOLS XCB_ATOM_CUT_BUFFER0
367 #define TYPE_MOTIF_WM_HINTS XCB_ATOM_CUT_BUFFER1
368 #define TYPE_NET_WM_STATE XCB_ATOM_CUT_BUFFER2
369 #define TYPE_WM_NORMAL_HINTS XCB_ATOM_CUT_BUFFER3
372 weston_wm_window_read_properties(struct weston_wm_window *window)
374 struct weston_wm *wm = window->wm;
375 struct weston_shell_interface *shell_interface =
376 &wm->server->compositor->shell_interface;
378 #define F(field) offsetof(struct weston_wm_window, field)
384 { XCB_ATOM_WM_CLASS, XCB_ATOM_STRING, F(class) },
385 { XCB_ATOM_WM_NAME, XCB_ATOM_STRING, F(name) },
386 { XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, F(transient_for) },
387 { wm->atom.wm_protocols, TYPE_WM_PROTOCOLS, F(protocols) },
388 { wm->atom.wm_normal_hints, TYPE_WM_NORMAL_HINTS, F(protocols) },
389 { wm->atom.net_wm_state, TYPE_NET_WM_STATE },
390 { wm->atom.net_wm_window_type, XCB_ATOM_ATOM, F(type) },
391 { wm->atom.net_wm_name, XCB_ATOM_STRING, F(name) },
392 { wm->atom.net_wm_pid, XCB_ATOM_CARDINAL, F(pid) },
393 { wm->atom.motif_wm_hints, TYPE_MOTIF_WM_HINTS, 0 },
394 { wm->atom.wm_client_machine, XCB_ATOM_WM_CLIENT_MACHINE, F(machine) },
398 xcb_get_property_cookie_t cookie[ARRAY_LENGTH(props)];
399 xcb_get_property_reply_t *reply;
405 if (!window->properties_dirty)
407 window->properties_dirty = 0;
409 for (i = 0; i < ARRAY_LENGTH(props); i++)
410 cookie[i] = xcb_get_property(wm->conn,
414 XCB_ATOM_ANY, 0, 2048);
416 window->decorate = !window->override_redirect;
417 window->size_hints.flags = 0;
418 window->motif_hints.flags = 0;
419 window->delete_window = 0;
421 for (i = 0; i < ARRAY_LENGTH(props); i++) {
422 reply = xcb_get_property_reply(wm->conn, cookie[i], NULL);
424 /* Bad window, typically */
426 if (reply->type == XCB_ATOM_NONE) {
427 /* No such property */
432 p = ((char *) window + props[i].offset);
434 switch (props[i].type) {
435 case XCB_ATOM_WM_CLIENT_MACHINE:
436 case XCB_ATOM_STRING:
437 /* FIXME: We're using this for both string and
443 strndup(xcb_get_property_value(reply),
444 xcb_get_property_value_length(reply));
446 case XCB_ATOM_WINDOW:
447 xid = xcb_get_property_value(reply);
448 *(struct weston_wm_window **) p =
449 hash_table_lookup(wm->window_hash, *xid);
451 case XCB_ATOM_CARDINAL:
453 atom = xcb_get_property_value(reply);
454 *(xcb_atom_t *) p = *atom;
456 case TYPE_WM_PROTOCOLS:
457 atom = xcb_get_property_value(reply);
458 for (i = 0; i < reply->value_len; i++)
459 if (atom[i] == wm->atom.wm_delete_window)
460 window->delete_window = 1;
464 case TYPE_WM_NORMAL_HINTS:
465 memcpy(&window->size_hints,
466 xcb_get_property_value(reply),
467 sizeof window->size_hints);
469 case TYPE_NET_WM_STATE:
470 window->fullscreen = 0;
471 atom = xcb_get_property_value(reply);
472 for (i = 0; i < reply->value_len; i++)
473 if (atom[i] == wm->atom.net_wm_state_fullscreen)
474 window->fullscreen = 1;
476 case TYPE_MOTIF_WM_HINTS:
477 memcpy(&window->motif_hints,
478 xcb_get_property_value(reply),
479 sizeof window->motif_hints);
480 if (window->motif_hints.flags & MWM_HINTS_DECORATIONS)
482 window->motif_hints.decorations > 0;
490 if (window->shsurf && window->name)
491 shell_interface->set_title(window->shsurf, window->name);
492 if (window->frame && window->name)
493 frame_set_title(window->frame, window->name);
497 weston_wm_window_get_frame_size(struct weston_wm_window *window,
498 int *width, int *height)
500 struct theme *t = window->wm->theme;
502 if (window->fullscreen) {
503 *width = window->width;
504 *height = window->height;
505 } else if (window->decorate && window->frame) {
506 *width = frame_width(window->frame);
507 *height = frame_height(window->frame);
509 *width = window->width + t->margin * 2;
510 *height = window->height + t->margin * 2;
515 weston_wm_window_get_child_position(struct weston_wm_window *window,
518 struct theme *t = window->wm->theme;
520 if (window->fullscreen) {
523 } else if (window->decorate && window->frame) {
524 frame_interior(window->frame, x, y, NULL, NULL);
532 weston_wm_window_send_configure_notify(struct weston_wm_window *window)
534 xcb_configure_notify_event_t configure_notify;
535 struct weston_wm *wm = window->wm;
538 weston_wm_window_get_child_position(window, &x, &y);
539 configure_notify.response_type = XCB_CONFIGURE_NOTIFY;
540 configure_notify.pad0 = 0;
541 configure_notify.event = window->id;
542 configure_notify.window = window->id;
543 configure_notify.above_sibling = XCB_WINDOW_NONE;
544 configure_notify.x = x;
545 configure_notify.y = y;
546 configure_notify.width = window->width;
547 configure_notify.height = window->height;
548 configure_notify.border_width = 0;
549 configure_notify.override_redirect = 0;
550 configure_notify.pad1 = 0;
552 xcb_send_event(wm->conn, 0, window->id,
553 XCB_EVENT_MASK_STRUCTURE_NOTIFY,
554 (char *) &configure_notify);
558 weston_wm_handle_configure_request(struct weston_wm *wm, xcb_generic_event_t *event)
560 xcb_configure_request_event_t *configure_request =
561 (xcb_configure_request_event_t *) event;
562 struct weston_wm_window *window;
563 uint32_t mask, values[16];
564 int x, y, width, height, i = 0;
566 wm_log("XCB_CONFIGURE_REQUEST (window %d) %d,%d @ %dx%d\n",
567 configure_request->window,
568 configure_request->x, configure_request->y,
569 configure_request->width, configure_request->height);
571 window = hash_table_lookup(wm->window_hash, configure_request->window);
573 if (window->fullscreen) {
574 weston_wm_window_send_configure_notify(window);
578 if (configure_request->value_mask & XCB_CONFIG_WINDOW_WIDTH)
579 window->width = configure_request->width;
580 if (configure_request->value_mask & XCB_CONFIG_WINDOW_HEIGHT)
581 window->height = configure_request->height;
584 frame_resize_inside(window->frame, window->width, window->height);
586 weston_wm_window_get_child_position(window, &x, &y);
589 values[i++] = window->width;
590 values[i++] = window->height;
592 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
593 XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
594 XCB_CONFIG_WINDOW_BORDER_WIDTH;
595 if (configure_request->value_mask & XCB_CONFIG_WINDOW_SIBLING) {
596 values[i++] = configure_request->sibling;
597 mask |= XCB_CONFIG_WINDOW_SIBLING;
599 if (configure_request->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
600 values[i++] = configure_request->stack_mode;
601 mask |= XCB_CONFIG_WINDOW_STACK_MODE;
604 xcb_configure_window(wm->conn, window->id, mask, values);
606 weston_wm_window_get_frame_size(window, &width, &height);
609 mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
610 xcb_configure_window(wm->conn, window->frame_id, mask, values);
612 weston_wm_window_schedule_repaint(window);
616 our_resource(struct weston_wm *wm, uint32_t id)
618 const xcb_setup_t *setup;
620 setup = xcb_get_setup(wm->conn);
622 return (id & ~setup->resource_id_mask) == setup->resource_id_base;
626 weston_wm_handle_configure_notify(struct weston_wm *wm, xcb_generic_event_t *event)
628 xcb_configure_notify_event_t *configure_notify =
629 (xcb_configure_notify_event_t *) event;
630 struct weston_wm_window *window;
632 wm_log("XCB_CONFIGURE_NOTIFY (window %d) %d,%d @ %dx%d\n",
633 configure_notify->window,
634 configure_notify->x, configure_notify->y,
635 configure_notify->width, configure_notify->height);
637 window = hash_table_lookup(wm->window_hash, configure_notify->window);
638 window->x = configure_notify->x;
639 window->y = configure_notify->y;
640 if (window->override_redirect) {
641 window->width = configure_notify->width;
642 window->height = configure_notify->height;
644 frame_resize_inside(window->frame,
645 window->width, window->height);
650 weston_wm_kill_client(struct wl_listener *listener, void *data)
652 struct weston_surface *surface = data;
653 struct weston_wm_window *window = get_wm_window(surface);
659 gethostname(name, 1024);
661 /* this is only one heuristic to guess the PID of a client is valid,
662 * assuming it's compliant with icccm and ewmh. Non-compliants and
663 * remote applications of course fail. */
664 if (!strcmp(window->machine, name) && window->pid != 0)
665 kill(window->pid, SIGKILL);
669 weston_wm_create_surface(struct wl_listener *listener, void *data)
671 struct weston_surface *surface = data;
672 struct weston_wm *wm =
673 container_of(listener,
674 struct weston_wm, create_surface_listener);
675 struct weston_wm_window *window;
677 if (wl_resource_get_client(surface->resource) != wm->server->client)
680 wl_list_for_each(window, &wm->unpaired_window_list, link)
681 if (window->surface_id ==
682 wl_resource_get_id(surface->resource)) {
683 xserver_map_shell_surface(window, surface);
684 window->surface_id = 0;
685 wl_list_remove(&window->link);
691 weston_wm_window_activate(struct wl_listener *listener, void *data)
693 struct weston_surface *surface = data;
694 struct weston_wm_window *window = NULL;
695 struct weston_wm *wm =
696 container_of(listener, struct weston_wm, activate_listener);
697 xcb_client_message_event_t client_message;
700 window = get_wm_window(surface);
704 if (window->override_redirect)
707 client_message.response_type = XCB_CLIENT_MESSAGE;
708 client_message.format = 32;
709 client_message.window = window->id;
710 client_message.type = wm->atom.wm_protocols;
711 client_message.data.data32[0] = wm->atom.wm_take_focus;
712 client_message.data.data32[1] = XCB_TIME_CURRENT_TIME;
714 xcb_send_event(wm->conn, 0, window->id,
715 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
716 (char *) &client_message);
718 xcb_set_input_focus (wm->conn, XCB_INPUT_FOCUS_POINTER_ROOT,
719 window->id, XCB_TIME_CURRENT_TIME);
721 xcb_set_input_focus (wm->conn,
722 XCB_INPUT_FOCUS_POINTER_ROOT,
724 XCB_TIME_CURRENT_TIME);
727 if (wm->focus_window) {
728 if (wm->focus_window->frame)
729 frame_unset_flag(wm->focus_window->frame, FRAME_FLAG_ACTIVE);
730 weston_wm_window_schedule_repaint(wm->focus_window);
732 wm->focus_window = window;
733 if (wm->focus_window) {
734 if (wm->focus_window->frame)
735 frame_set_flag(wm->focus_window->frame, FRAME_FLAG_ACTIVE);
736 weston_wm_window_schedule_repaint(wm->focus_window);
741 weston_wm_window_transform(struct wl_listener *listener, void *data)
743 struct weston_surface *surface = data;
744 struct weston_wm_window *window = get_wm_window(surface);
745 struct weston_wm *wm =
746 container_of(listener, struct weston_wm, transform_listener);
747 uint32_t mask, values[2];
752 if (!window->view || !weston_view_is_mapped(window->view))
755 if (window->x != window->view->geometry.x ||
756 window->y != window->view->geometry.y) {
757 values[0] = window->view->geometry.x;
758 values[1] = window->view->geometry.y;
759 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y;
761 xcb_configure_window(wm->conn, window->frame_id, mask, values);
766 #define ICCCM_WITHDRAWN_STATE 0
767 #define ICCCM_NORMAL_STATE 1
768 #define ICCCM_ICONIC_STATE 3
771 weston_wm_window_set_wm_state(struct weston_wm_window *window, int32_t state)
773 struct weston_wm *wm = window->wm;
774 uint32_t property[2];
777 property[1] = XCB_WINDOW_NONE;
779 xcb_change_property(wm->conn,
780 XCB_PROP_MODE_REPLACE,
789 weston_wm_window_set_net_wm_state(struct weston_wm_window *window)
791 struct weston_wm *wm = window->wm;
792 uint32_t property[1];
796 if (window->fullscreen)
797 property[i++] = wm->atom.net_wm_state_fullscreen;
799 xcb_change_property(wm->conn,
800 XCB_PROP_MODE_REPLACE,
802 wm->atom.net_wm_state,
809 weston_wm_window_create_frame(struct weston_wm_window *window)
811 struct weston_wm *wm = window->wm;
813 int x, y, width, height;
815 window->frame = frame_create(window->wm->theme,
816 window->width, window->height,
817 FRAME_BUTTON_CLOSE, window->name);
818 frame_resize_inside(window->frame, window->width, window->height);
820 weston_wm_window_get_frame_size(window, &width, &height);
821 weston_wm_window_get_child_position(window, &x, &y);
823 values[0] = wm->screen->black_pixel;
825 XCB_EVENT_MASK_KEY_PRESS |
826 XCB_EVENT_MASK_KEY_RELEASE |
827 XCB_EVENT_MASK_BUTTON_PRESS |
828 XCB_EVENT_MASK_BUTTON_RELEASE |
829 XCB_EVENT_MASK_POINTER_MOTION |
830 XCB_EVENT_MASK_ENTER_WINDOW |
831 XCB_EVENT_MASK_LEAVE_WINDOW |
832 XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
833 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
834 values[2] = wm->colormap;
836 window->frame_id = xcb_generate_id(wm->conn);
837 xcb_create_window(wm->conn,
844 XCB_WINDOW_CLASS_INPUT_OUTPUT,
846 XCB_CW_BORDER_PIXEL |
848 XCB_CW_COLORMAP, values);
850 xcb_reparent_window(wm->conn, window->id, window->frame_id, x, y);
853 xcb_configure_window(wm->conn, window->id,
854 XCB_CONFIG_WINDOW_BORDER_WIDTH, values);
856 window->cairo_surface =
857 cairo_xcb_surface_create_with_xrender_format(wm->conn,
863 hash_table_insert(wm->window_hash, window->frame_id, window);
867 weston_wm_handle_map_request(struct weston_wm *wm, xcb_generic_event_t *event)
869 xcb_map_request_event_t *map_request =
870 (xcb_map_request_event_t *) event;
871 struct weston_wm_window *window;
873 if (our_resource(wm, map_request->window)) {
874 wm_log("XCB_MAP_REQUEST (window %d, ours)\n",
875 map_request->window);
879 window = hash_table_lookup(wm->window_hash, map_request->window);
881 weston_wm_window_read_properties(window);
883 if (window->frame_id == XCB_WINDOW_NONE)
884 weston_wm_window_create_frame(window);
886 wm_log("XCB_MAP_REQUEST (window %d, %p, frame %d)\n",
887 window->id, window, window->frame_id);
889 weston_wm_window_set_wm_state(window, ICCCM_NORMAL_STATE);
890 weston_wm_window_set_net_wm_state(window);
892 xcb_map_window(wm->conn, map_request->window);
893 xcb_map_window(wm->conn, window->frame_id);
897 weston_wm_handle_map_notify(struct weston_wm *wm, xcb_generic_event_t *event)
899 xcb_map_notify_event_t *map_notify = (xcb_map_notify_event_t *) event;
901 if (our_resource(wm, map_notify->window)) {
902 wm_log("XCB_MAP_NOTIFY (window %d, ours)\n",
907 wm_log("XCB_MAP_NOTIFY (window %d)\n", map_notify->window);
911 weston_wm_handle_unmap_notify(struct weston_wm *wm, xcb_generic_event_t *event)
913 xcb_unmap_notify_event_t *unmap_notify =
914 (xcb_unmap_notify_event_t *) event;
915 struct weston_wm_window *window;
917 wm_log("XCB_UNMAP_NOTIFY (window %d, event %d%s)\n",
918 unmap_notify->window,
920 our_resource(wm, unmap_notify->window) ? ", ours" : "");
922 if (our_resource(wm, unmap_notify->window))
925 if (unmap_notify->response_type & SEND_EVENT_MASK)
926 /* We just ignore the ICCCM 4.1.4 synthetic unmap notify
927 * as it may come in after we've destroyed the window. */
930 window = hash_table_lookup(wm->window_hash, unmap_notify->window);
931 if (wm->focus_window == window)
932 wm->focus_window = NULL;
934 wl_list_remove(&window->surface_destroy_listener.link);
935 window->surface = NULL;
936 window->shsurf = NULL;
938 xcb_unmap_window(wm->conn, window->frame_id);
942 weston_wm_window_draw_decoration(void *data)
944 struct weston_wm_window *window = data;
945 struct weston_wm *wm = window->wm;
946 struct theme *t = wm->theme;
948 int x, y, width, height;
949 int32_t input_x, input_y, input_w, input_h;
950 struct weston_shell_interface *shell_interface =
951 &wm->server->compositor->shell_interface;
954 weston_wm_window_read_properties(window);
956 window->repaint_source = NULL;
958 weston_wm_window_get_frame_size(window, &width, &height);
959 weston_wm_window_get_child_position(window, &x, &y);
961 cairo_xcb_surface_set_size(window->cairo_surface, width, height);
962 cr = cairo_create(window->cairo_surface);
964 if (window->fullscreen) {
966 } else if (window->decorate) {
967 if (wm->focus_window == window)
968 flags |= THEME_FRAME_ACTIVE;
970 frame_repaint(window->frame, cr);
972 cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
973 cairo_set_source_rgba(cr, 0, 0, 0, 0);
976 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
977 cairo_set_source_rgba(cr, 0, 0, 0, 0.45);
978 tile_mask(cr, t->shadow, 2, 2, width + 8, height + 8, 64, 64);
983 if (window->surface) {
984 pixman_region32_fini(&window->surface->pending.opaque);
985 if(window->has_alpha) {
986 pixman_region32_init(&window->surface->pending.opaque);
988 /* We leave an extra pixel around the X window area to
989 * make sure we don't sample from the undefined alpha
990 * channel when filtering. */
991 pixman_region32_init_rect(&window->surface->pending.opaque,
997 weston_view_geometry_dirty(window->view);
999 pixman_region32_fini(&window->surface->pending.input);
1001 if (window->fullscreen) {
1004 input_w = window->width;
1005 input_h = window->height;
1006 } else if (window->decorate) {
1007 frame_input_rect(window->frame, &input_x, &input_y,
1008 &input_w, &input_h);
1011 pixman_region32_init_rect(&window->surface->pending.input,
1012 input_x, input_y, input_w, input_h);
1014 shell_interface->set_window_geometry(window->shsurf,
1015 input_x, input_y, input_w, input_h);
1020 weston_wm_window_schedule_repaint(struct weston_wm_window *window)
1022 struct weston_wm *wm = window->wm;
1025 if (window->frame_id == XCB_WINDOW_NONE) {
1026 if (window->surface != NULL) {
1027 weston_wm_window_get_frame_size(window, &width, &height);
1028 pixman_region32_fini(&window->surface->pending.opaque);
1029 if(window->has_alpha) {
1030 pixman_region32_init(&window->surface->pending.opaque);
1032 pixman_region32_init_rect(&window->surface->pending.opaque, 0, 0,
1036 weston_view_geometry_dirty(window->view);
1041 if (window->repaint_source)
1044 window->repaint_source =
1045 wl_event_loop_add_idle(wm->server->loop,
1046 weston_wm_window_draw_decoration,
1051 weston_wm_handle_property_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1053 xcb_property_notify_event_t *property_notify =
1054 (xcb_property_notify_event_t *) event;
1055 struct weston_wm_window *window;
1057 window = hash_table_lookup(wm->window_hash, property_notify->window);
1061 window->properties_dirty = 1;
1063 wm_log("XCB_PROPERTY_NOTIFY: window %d, ", property_notify->window);
1064 if (property_notify->state == XCB_PROPERTY_DELETE)
1065 wm_log("deleted\n");
1067 read_and_dump_property(wm, property_notify->window,
1068 property_notify->atom);
1070 if (property_notify->atom == wm->atom.net_wm_name ||
1071 property_notify->atom == XCB_ATOM_WM_NAME)
1072 weston_wm_window_schedule_repaint(window);
1076 weston_wm_window_create(struct weston_wm *wm,
1077 xcb_window_t id, int width, int height, int x, int y, int override)
1079 struct weston_wm_window *window;
1081 xcb_get_geometry_cookie_t geometry_cookie;
1082 xcb_get_geometry_reply_t *geometry_reply;
1084 window = zalloc(sizeof *window);
1085 if (window == NULL) {
1086 wm_log("failed to allocate window\n");
1090 geometry_cookie = xcb_get_geometry(wm->conn, id);
1092 values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE;
1093 xcb_change_window_attributes(wm->conn, id, XCB_CW_EVENT_MASK, values);
1097 window->properties_dirty = 1;
1098 window->override_redirect = override;
1099 window->width = width;
1100 window->height = height;
1104 geometry_reply = xcb_get_geometry_reply(wm->conn, geometry_cookie, NULL);
1105 /* technically we should use XRender and check the visual format's
1106 alpha_mask, but checking depth is simpler and works in all known cases */
1107 if(geometry_reply != NULL)
1108 window->has_alpha = geometry_reply->depth == 32;
1109 free(geometry_reply);
1111 hash_table_insert(wm->window_hash, id, window);
1115 weston_wm_window_destroy(struct weston_wm_window *window)
1117 struct weston_wm *wm = window->wm;
1119 if (window->repaint_source)
1120 wl_event_source_remove(window->repaint_source);
1121 if (window->cairo_surface)
1122 cairo_surface_destroy(window->cairo_surface);
1124 if (window->frame_id) {
1125 xcb_reparent_window(wm->conn, window->id, wm->wm_window, 0, 0);
1126 xcb_destroy_window(wm->conn, window->frame_id);
1127 weston_wm_window_set_wm_state(window, ICCCM_WITHDRAWN_STATE);
1128 hash_table_remove(wm->window_hash, window->frame_id);
1129 window->frame_id = XCB_WINDOW_NONE;
1132 if (window->surface_id)
1133 wl_list_remove(&window->link);
1135 hash_table_remove(window->wm->window_hash, window->id);
1140 weston_wm_handle_create_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1142 xcb_create_notify_event_t *create_notify =
1143 (xcb_create_notify_event_t *) event;
1145 wm_log("XCB_CREATE_NOTIFY (window %d, width %d, height %d%s%s)\n",
1146 create_notify->window,
1147 create_notify->width, create_notify->height,
1148 create_notify->override_redirect ? ", override" : "",
1149 our_resource(wm, create_notify->window) ? ", ours" : "");
1151 if (our_resource(wm, create_notify->window))
1154 weston_wm_window_create(wm, create_notify->window,
1155 create_notify->width, create_notify->height,
1156 create_notify->x, create_notify->y,
1157 create_notify->override_redirect);
1161 weston_wm_handle_destroy_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1163 xcb_destroy_notify_event_t *destroy_notify =
1164 (xcb_destroy_notify_event_t *) event;
1165 struct weston_wm_window *window;
1167 wm_log("XCB_DESTROY_NOTIFY, win %d, event %d%s\n",
1168 destroy_notify->window,
1169 destroy_notify->event,
1170 our_resource(wm, destroy_notify->window) ? ", ours" : "");
1172 if (our_resource(wm, destroy_notify->window))
1175 window = hash_table_lookup(wm->window_hash, destroy_notify->window);
1176 weston_wm_window_destroy(window);
1180 weston_wm_handle_reparent_notify(struct weston_wm *wm, xcb_generic_event_t *event)
1182 xcb_reparent_notify_event_t *reparent_notify =
1183 (xcb_reparent_notify_event_t *) event;
1184 struct weston_wm_window *window;
1186 wm_log("XCB_REPARENT_NOTIFY (window %d, parent %d, event %d)\n",
1187 reparent_notify->window,
1188 reparent_notify->parent,
1189 reparent_notify->event);
1191 if (reparent_notify->parent == wm->screen->root) {
1192 weston_wm_window_create(wm, reparent_notify->window, 10, 10,
1193 reparent_notify->x, reparent_notify->y,
1194 reparent_notify->override_redirect);
1195 } else if (!our_resource(wm, reparent_notify->parent)) {
1196 window = hash_table_lookup(wm->window_hash,
1197 reparent_notify->window);
1198 weston_wm_window_destroy(window);
1202 struct weston_seat *
1203 weston_wm_pick_seat(struct weston_wm *wm)
1205 return container_of(wm->server->compositor->seat_list.next,
1206 struct weston_seat, link);
1209 static struct weston_seat *
1210 weston_wm_pick_seat_for_window(struct weston_wm_window *window)
1212 struct weston_wm *wm = window->wm;
1213 struct weston_seat *seat, *s;
1216 wl_list_for_each(s, &wm->server->compositor->seat_list, link) {
1217 if (s->pointer != NULL &&
1218 s->pointer->focus == window->view &&
1219 s->pointer->button_count > 0 &&
1221 s->pointer->grab_serial -
1222 seat->pointer->grab_serial < (1 << 30)))
1230 weston_wm_window_handle_moveresize(struct weston_wm_window *window,
1231 xcb_client_message_event_t *client_message)
1233 static const int map[] = {
1234 THEME_LOCATION_RESIZING_TOP_LEFT,
1235 THEME_LOCATION_RESIZING_TOP,
1236 THEME_LOCATION_RESIZING_TOP_RIGHT,
1237 THEME_LOCATION_RESIZING_RIGHT,
1238 THEME_LOCATION_RESIZING_BOTTOM_RIGHT,
1239 THEME_LOCATION_RESIZING_BOTTOM,
1240 THEME_LOCATION_RESIZING_BOTTOM_LEFT,
1241 THEME_LOCATION_RESIZING_LEFT
1244 struct weston_wm *wm = window->wm;
1245 struct weston_seat *seat = weston_wm_pick_seat_for_window(window);
1247 struct weston_shell_interface *shell_interface =
1248 &wm->server->compositor->shell_interface;
1250 if (seat == NULL || seat->pointer->button_count != 1
1251 || !window->view || seat->pointer->focus != window->view)
1254 detail = client_message->data.data32[2];
1256 case _NET_WM_MOVERESIZE_MOVE:
1257 shell_interface->move(window->shsurf, seat);
1259 case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
1260 case _NET_WM_MOVERESIZE_SIZE_TOP:
1261 case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
1262 case _NET_WM_MOVERESIZE_SIZE_RIGHT:
1263 case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
1264 case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
1265 case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
1266 case _NET_WM_MOVERESIZE_SIZE_LEFT:
1267 shell_interface->resize(window->shsurf, seat, map[detail]);
1269 case _NET_WM_MOVERESIZE_CANCEL:
1274 #define _NET_WM_STATE_REMOVE 0
1275 #define _NET_WM_STATE_ADD 1
1276 #define _NET_WM_STATE_TOGGLE 2
1279 update_state(int action, int *state)
1281 int new_state, changed;
1284 case _NET_WM_STATE_REMOVE:
1287 case _NET_WM_STATE_ADD:
1290 case _NET_WM_STATE_TOGGLE:
1291 new_state = !*state;
1297 changed = (*state != new_state);
1304 weston_wm_window_configure(void *data);
1307 weston_wm_window_handle_state(struct weston_wm_window *window,
1308 xcb_client_message_event_t *client_message)
1310 struct weston_wm *wm = window->wm;
1311 struct weston_shell_interface *shell_interface =
1312 &wm->server->compositor->shell_interface;
1313 uint32_t action, property;
1315 action = client_message->data.data32[0];
1316 property = client_message->data.data32[1];
1318 if (property == wm->atom.net_wm_state_fullscreen &&
1319 update_state(action, &window->fullscreen)) {
1320 weston_wm_window_set_net_wm_state(window);
1321 if (window->fullscreen) {
1322 window->saved_width = window->width;
1323 window->saved_height = window->height;
1326 shell_interface->set_fullscreen(window->shsurf,
1327 WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
1330 shell_interface->set_toplevel(window->shsurf);
1331 window->width = window->saved_width;
1332 window->height = window->saved_height;
1334 frame_resize_inside(window->frame,
1337 weston_wm_window_configure(window);
1343 surface_destroy(struct wl_listener *listener, void *data)
1345 struct weston_wm_window *window =
1346 container_of(listener,
1347 struct weston_wm_window, surface_destroy_listener);
1349 wm_log("surface for xid %d destroyed\n", window->id);
1351 /* This should have been freed by the shell.
1352 * Don't try to use it later. */
1353 window->shsurf = NULL;
1354 window->surface = NULL;
1355 window->view = NULL;
1359 weston_wm_window_handle_surface_id(struct weston_wm_window *window,
1360 xcb_client_message_event_t *client_message)
1362 struct weston_wm *wm = window->wm;
1363 struct wl_resource *resource;
1365 if (window->surface_id != 0) {
1366 wm_log("already have surface id for window %d\n", window->id);
1370 /* Xwayland will send the wayland requests to create the
1371 * wl_surface before sending this client message. Even so, we
1372 * can end up handling the X event before the wayland requests
1373 * and thus when we try to look up the surface ID, the surface
1374 * hasn't been created yet. In that case put the window on
1375 * the unpaired window list and continue when the surface gets
1377 uint32_t id = client_message->data.data32[0];
1378 resource = wl_client_get_object(wm->server->client, id);
1380 window->surface_id = 0;
1381 xserver_map_shell_surface(window,
1382 wl_resource_get_user_data(resource));
1385 window->surface_id = id;
1386 wl_list_insert(&wm->unpaired_window_list, &window->link);
1391 weston_wm_handle_client_message(struct weston_wm *wm,
1392 xcb_generic_event_t *event)
1394 xcb_client_message_event_t *client_message =
1395 (xcb_client_message_event_t *) event;
1396 struct weston_wm_window *window;
1398 window = hash_table_lookup(wm->window_hash, client_message->window);
1400 wm_log("XCB_CLIENT_MESSAGE (%s %d %d %d %d %d win %d)\n",
1401 get_atom_name(wm->conn, client_message->type),
1402 client_message->data.data32[0],
1403 client_message->data.data32[1],
1404 client_message->data.data32[2],
1405 client_message->data.data32[3],
1406 client_message->data.data32[4],
1407 client_message->window);
1409 /* The window may get created and destroyed before we actually
1410 * handle the message. If it doesn't exist, bail.
1415 if (client_message->type == wm->atom.net_wm_moveresize)
1416 weston_wm_window_handle_moveresize(window, client_message);
1417 else if (client_message->type == wm->atom.net_wm_state)
1418 weston_wm_window_handle_state(window, client_message);
1419 else if (client_message->type == wm->atom.wl_surface_id)
1420 weston_wm_window_handle_surface_id(window, client_message);
1428 XWM_CURSOR_TOP_LEFT,
1429 XWM_CURSOR_TOP_RIGHT,
1430 XWM_CURSOR_BOTTOM_LEFT,
1431 XWM_CURSOR_BOTTOM_RIGHT,
1432 XWM_CURSOR_LEFT_PTR,
1436 * The following correspondences between file names and cursors was copied
1437 * from: https://bugs.kde.org/attachment.cgi?id=67313
1440 static const char *bottom_left_corners[] = {
1441 "bottom_left_corner",
1446 static const char *bottom_right_corners[] = {
1447 "bottom_right_corner",
1452 static const char *bottom_sides[] = {
1458 static const char *left_ptrs[] = {
1465 static const char *left_sides[] = {
1471 static const char *right_sides[] = {
1477 static const char *top_left_corners[] = {
1483 static const char *top_right_corners[] = {
1489 static const char *top_sides[] = {
1495 struct cursor_alternatives {
1500 static const struct cursor_alternatives cursors[] = {
1501 {top_sides, ARRAY_LENGTH(top_sides)},
1502 {bottom_sides, ARRAY_LENGTH(bottom_sides)},
1503 {left_sides, ARRAY_LENGTH(left_sides)},
1504 {right_sides, ARRAY_LENGTH(right_sides)},
1505 {top_left_corners, ARRAY_LENGTH(top_left_corners)},
1506 {top_right_corners, ARRAY_LENGTH(top_right_corners)},
1507 {bottom_left_corners, ARRAY_LENGTH(bottom_left_corners)},
1508 {bottom_right_corners, ARRAY_LENGTH(bottom_right_corners)},
1509 {left_ptrs, ARRAY_LENGTH(left_ptrs)},
1513 weston_wm_create_cursors(struct weston_wm *wm)
1516 int i, count = ARRAY_LENGTH(cursors);
1519 wm->cursors = malloc(count * sizeof(xcb_cursor_t));
1520 for (i = 0; i < count; i++) {
1521 for (j = 0; j < cursors[i].count; j++) {
1522 name = cursors[i].names[j];
1524 xcb_cursor_library_load_cursor(wm, name);
1525 if (wm->cursors[i] != (xcb_cursor_t)-1)
1530 wm->last_cursor = -1;
1534 weston_wm_destroy_cursors(struct weston_wm *wm)
1538 for (i = 0; i < ARRAY_LENGTH(cursors); i++)
1539 xcb_free_cursor(wm->conn, wm->cursors[i]);
1545 get_cursor_for_location(enum theme_location location)
1547 // int location = theme_get_location(t, x, y, width, height, 0);
1550 case THEME_LOCATION_RESIZING_TOP:
1551 return XWM_CURSOR_TOP;
1552 case THEME_LOCATION_RESIZING_BOTTOM:
1553 return XWM_CURSOR_BOTTOM;
1554 case THEME_LOCATION_RESIZING_LEFT:
1555 return XWM_CURSOR_LEFT;
1556 case THEME_LOCATION_RESIZING_RIGHT:
1557 return XWM_CURSOR_RIGHT;
1558 case THEME_LOCATION_RESIZING_TOP_LEFT:
1559 return XWM_CURSOR_TOP_LEFT;
1560 case THEME_LOCATION_RESIZING_TOP_RIGHT:
1561 return XWM_CURSOR_TOP_RIGHT;
1562 case THEME_LOCATION_RESIZING_BOTTOM_LEFT:
1563 return XWM_CURSOR_BOTTOM_LEFT;
1564 case THEME_LOCATION_RESIZING_BOTTOM_RIGHT:
1565 return XWM_CURSOR_BOTTOM_RIGHT;
1566 case THEME_LOCATION_EXTERIOR:
1567 case THEME_LOCATION_TITLEBAR:
1569 return XWM_CURSOR_LEFT_PTR;
1574 weston_wm_window_set_cursor(struct weston_wm *wm, xcb_window_t window_id,
1577 uint32_t cursor_value_list;
1579 if (wm->last_cursor == cursor)
1582 wm->last_cursor = cursor;
1584 cursor_value_list = wm->cursors[cursor];
1585 xcb_change_window_attributes (wm->conn, window_id,
1586 XCB_CW_CURSOR, &cursor_value_list);
1587 xcb_flush(wm->conn);
1591 weston_wm_window_close(struct weston_wm_window *window, xcb_timestamp_t time)
1593 xcb_client_message_event_t client_message;
1595 if (window->delete_window) {
1596 client_message.response_type = XCB_CLIENT_MESSAGE;
1597 client_message.format = 32;
1598 client_message.window = window->id;
1599 client_message.type = window->wm->atom.wm_protocols;
1600 client_message.data.data32[0] =
1601 window->wm->atom.wm_delete_window;
1602 client_message.data.data32[1] = time;
1604 xcb_send_event(window->wm->conn, 0, window->id,
1605 XCB_EVENT_MASK_NO_EVENT,
1606 (char *) &client_message);
1608 xcb_kill_client(window->wm->conn, window->id);
1613 weston_wm_handle_button(struct weston_wm *wm, xcb_generic_event_t *event)
1615 xcb_button_press_event_t *button = (xcb_button_press_event_t *) event;
1616 struct weston_shell_interface *shell_interface =
1617 &wm->server->compositor->shell_interface;
1618 struct weston_seat *seat;
1619 struct weston_wm_window *window;
1620 enum theme_location location;
1621 enum frame_button_state button_state;
1624 wm_log("XCB_BUTTON_%s (detail %d)\n",
1625 button->response_type == XCB_BUTTON_PRESS ?
1626 "PRESS" : "RELEASE", button->detail);
1628 window = hash_table_lookup(wm->window_hash, button->event);
1629 if (!window || !window->decorate)
1632 if (button->detail != 1 && button->detail != 2)
1635 seat = weston_wm_pick_seat_for_window(window);
1637 button_state = button->response_type == XCB_BUTTON_PRESS ?
1638 FRAME_BUTTON_PRESSED : FRAME_BUTTON_RELEASED;
1639 button_id = button->detail == 1 ? BTN_LEFT : BTN_RIGHT;
1641 /* Make sure we're looking at the right location. The frame
1642 * could have received a motion event from a pointer from a
1643 * different wl_seat, but under X it looks like our core
1644 * pointer moved. Move the frame pointer to the button press
1645 * location before deciding what to do. */
1646 location = frame_pointer_motion(window->frame, NULL,
1647 button->event_x, button->event_y);
1648 location = frame_pointer_button(window->frame, NULL,
1649 button_id, button_state);
1650 if (frame_status(window->frame) & FRAME_STATUS_REPAINT)
1651 weston_wm_window_schedule_repaint(window);
1653 if (frame_status(window->frame) & FRAME_STATUS_MOVE) {
1655 shell_interface->move(window->shsurf, seat);
1656 frame_status_clear(window->frame, FRAME_STATUS_MOVE);
1659 if (frame_status(window->frame) & FRAME_STATUS_RESIZE) {
1661 shell_interface->resize(window->shsurf, seat, location);
1662 frame_status_clear(window->frame, FRAME_STATUS_RESIZE);
1665 if (frame_status(window->frame) & FRAME_STATUS_CLOSE) {
1666 weston_wm_window_close(window, button->time);
1667 frame_status_clear(window->frame, FRAME_STATUS_CLOSE);
1672 weston_wm_handle_motion(struct weston_wm *wm, xcb_generic_event_t *event)
1674 xcb_motion_notify_event_t *motion = (xcb_motion_notify_event_t *) event;
1675 struct weston_wm_window *window;
1676 enum theme_location location;
1679 window = hash_table_lookup(wm->window_hash, motion->event);
1680 if (!window || !window->decorate)
1683 location = frame_pointer_motion(window->frame, NULL,
1684 motion->event_x, motion->event_y);
1685 if (frame_status(window->frame) & FRAME_STATUS_REPAINT)
1686 weston_wm_window_schedule_repaint(window);
1688 cursor = get_cursor_for_location(location);
1689 weston_wm_window_set_cursor(wm, window->frame_id, cursor);
1693 weston_wm_handle_enter(struct weston_wm *wm, xcb_generic_event_t *event)
1695 xcb_enter_notify_event_t *enter = (xcb_enter_notify_event_t *) event;
1696 struct weston_wm_window *window;
1697 enum theme_location location;
1700 window = hash_table_lookup(wm->window_hash, enter->event);
1701 if (!window || !window->decorate)
1704 location = frame_pointer_enter(window->frame, NULL,
1705 enter->event_x, enter->event_y);
1706 if (frame_status(window->frame) & FRAME_STATUS_REPAINT)
1707 weston_wm_window_schedule_repaint(window);
1709 cursor = get_cursor_for_location(location);
1710 weston_wm_window_set_cursor(wm, window->frame_id, cursor);
1714 weston_wm_handle_leave(struct weston_wm *wm, xcb_generic_event_t *event)
1716 xcb_leave_notify_event_t *leave = (xcb_leave_notify_event_t *) event;
1717 struct weston_wm_window *window;
1719 window = hash_table_lookup(wm->window_hash, leave->event);
1720 if (!window || !window->decorate)
1723 frame_pointer_leave(window->frame, NULL);
1724 if (frame_status(window->frame) & FRAME_STATUS_REPAINT)
1725 weston_wm_window_schedule_repaint(window);
1727 weston_wm_window_set_cursor(wm, window->frame_id, XWM_CURSOR_LEFT_PTR);
1731 weston_wm_handle_event(int fd, uint32_t mask, void *data)
1733 struct weston_wm *wm = data;
1734 xcb_generic_event_t *event;
1737 while (event = xcb_poll_for_event(wm->conn), event != NULL) {
1738 if (weston_wm_handle_selection_event(wm, event)) {
1744 if (weston_wm_handle_dnd_event(wm, event)) {
1750 switch (EVENT_TYPE(event)) {
1751 case XCB_BUTTON_PRESS:
1752 case XCB_BUTTON_RELEASE:
1753 weston_wm_handle_button(wm, event);
1755 case XCB_ENTER_NOTIFY:
1756 weston_wm_handle_enter(wm, event);
1758 case XCB_LEAVE_NOTIFY:
1759 weston_wm_handle_leave(wm, event);
1761 case XCB_MOTION_NOTIFY:
1762 weston_wm_handle_motion(wm, event);
1764 case XCB_CREATE_NOTIFY:
1765 weston_wm_handle_create_notify(wm, event);
1767 case XCB_MAP_REQUEST:
1768 weston_wm_handle_map_request(wm, event);
1770 case XCB_MAP_NOTIFY:
1771 weston_wm_handle_map_notify(wm, event);
1773 case XCB_UNMAP_NOTIFY:
1774 weston_wm_handle_unmap_notify(wm, event);
1776 case XCB_REPARENT_NOTIFY:
1777 weston_wm_handle_reparent_notify(wm, event);
1779 case XCB_CONFIGURE_REQUEST:
1780 weston_wm_handle_configure_request(wm, event);
1782 case XCB_CONFIGURE_NOTIFY:
1783 weston_wm_handle_configure_notify(wm, event);
1785 case XCB_DESTROY_NOTIFY:
1786 weston_wm_handle_destroy_notify(wm, event);
1788 case XCB_MAPPING_NOTIFY:
1789 wm_log("XCB_MAPPING_NOTIFY\n");
1791 case XCB_PROPERTY_NOTIFY:
1792 weston_wm_handle_property_notify(wm, event);
1794 case XCB_CLIENT_MESSAGE:
1795 weston_wm_handle_client_message(wm, event);
1803 xcb_flush(wm->conn);
1809 weston_wm_get_visual_and_colormap(struct weston_wm *wm)
1811 xcb_depth_iterator_t d_iter;
1812 xcb_visualtype_iterator_t vt_iter;
1813 xcb_visualtype_t *visualtype;
1815 d_iter = xcb_screen_allowed_depths_iterator(wm->screen);
1817 while (d_iter.rem > 0) {
1818 if (d_iter.data->depth == 32) {
1819 vt_iter = xcb_depth_visuals_iterator(d_iter.data);
1820 visualtype = vt_iter.data;
1824 xcb_depth_next(&d_iter);
1827 if (visualtype == NULL) {
1828 weston_log("no 32 bit visualtype\n");
1832 wm->visual_id = visualtype->visual_id;
1833 wm->colormap = xcb_generate_id(wm->conn);
1834 xcb_create_colormap(wm->conn, XCB_COLORMAP_ALLOC_NONE,
1835 wm->colormap, wm->screen->root, wm->visual_id);
1839 weston_wm_get_resources(struct weston_wm *wm)
1842 #define F(field) offsetof(struct weston_wm, field)
1844 static const struct { const char *name; int offset; } atoms[] = {
1845 { "WM_PROTOCOLS", F(atom.wm_protocols) },
1846 { "WM_NORMAL_HINTS", F(atom.wm_normal_hints) },
1847 { "WM_TAKE_FOCUS", F(atom.wm_take_focus) },
1848 { "WM_DELETE_WINDOW", F(atom.wm_delete_window) },
1849 { "WM_STATE", F(atom.wm_state) },
1850 { "WM_S0", F(atom.wm_s0) },
1851 { "WM_CLIENT_MACHINE", F(atom.wm_client_machine) },
1852 { "_NET_WM_CM_S0", F(atom.net_wm_cm_s0) },
1853 { "_NET_WM_NAME", F(atom.net_wm_name) },
1854 { "_NET_WM_PID", F(atom.net_wm_pid) },
1855 { "_NET_WM_ICON", F(atom.net_wm_icon) },
1856 { "_NET_WM_STATE", F(atom.net_wm_state) },
1857 { "_NET_WM_STATE_FULLSCREEN", F(atom.net_wm_state_fullscreen) },
1858 { "_NET_WM_USER_TIME", F(atom.net_wm_user_time) },
1859 { "_NET_WM_ICON_NAME", F(atom.net_wm_icon_name) },
1860 { "_NET_WM_WINDOW_TYPE", F(atom.net_wm_window_type) },
1862 { "_NET_WM_WINDOW_TYPE_DESKTOP", F(atom.net_wm_window_type_desktop) },
1863 { "_NET_WM_WINDOW_TYPE_DOCK", F(atom.net_wm_window_type_dock) },
1864 { "_NET_WM_WINDOW_TYPE_TOOLBAR", F(atom.net_wm_window_type_toolbar) },
1865 { "_NET_WM_WINDOW_TYPE_MENU", F(atom.net_wm_window_type_menu) },
1866 { "_NET_WM_WINDOW_TYPE_UTILITY", F(atom.net_wm_window_type_utility) },
1867 { "_NET_WM_WINDOW_TYPE_SPLASH", F(atom.net_wm_window_type_splash) },
1868 { "_NET_WM_WINDOW_TYPE_DIALOG", F(atom.net_wm_window_type_dialog) },
1869 { "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", F(atom.net_wm_window_type_dropdown) },
1870 { "_NET_WM_WINDOW_TYPE_POPUP_MENU", F(atom.net_wm_window_type_popup) },
1871 { "_NET_WM_WINDOW_TYPE_TOOLTIP", F(atom.net_wm_window_type_tooltip) },
1872 { "_NET_WM_WINDOW_TYPE_NOTIFICATION", F(atom.net_wm_window_type_notification) },
1873 { "_NET_WM_WINDOW_TYPE_COMBO", F(atom.net_wm_window_type_combo) },
1874 { "_NET_WM_WINDOW_TYPE_DND", F(atom.net_wm_window_type_dnd) },
1875 { "_NET_WM_WINDOW_TYPE_NORMAL", F(atom.net_wm_window_type_normal) },
1877 { "_NET_WM_MOVERESIZE", F(atom.net_wm_moveresize) },
1878 { "_NET_SUPPORTING_WM_CHECK",
1879 F(atom.net_supporting_wm_check) },
1880 { "_NET_SUPPORTED", F(atom.net_supported) },
1881 { "_MOTIF_WM_HINTS", F(atom.motif_wm_hints) },
1882 { "CLIPBOARD", F(atom.clipboard) },
1883 { "CLIPBOARD_MANAGER", F(atom.clipboard_manager) },
1884 { "TARGETS", F(atom.targets) },
1885 { "UTF8_STRING", F(atom.utf8_string) },
1886 { "_WL_SELECTION", F(atom.wl_selection) },
1887 { "INCR", F(atom.incr) },
1888 { "TIMESTAMP", F(atom.timestamp) },
1889 { "MULTIPLE", F(atom.multiple) },
1890 { "UTF8_STRING" , F(atom.utf8_string) },
1891 { "COMPOUND_TEXT", F(atom.compound_text) },
1892 { "TEXT", F(atom.text) },
1893 { "STRING", F(atom.string) },
1894 { "text/plain;charset=utf-8", F(atom.text_plain_utf8) },
1895 { "text/plain", F(atom.text_plain) },
1896 { "XdndSelection", F(atom.xdnd_selection) },
1897 { "XdndAware", F(atom.xdnd_aware) },
1898 { "XdndEnter", F(atom.xdnd_enter) },
1899 { "XdndLeave", F(atom.xdnd_leave) },
1900 { "XdndDrop", F(atom.xdnd_drop) },
1901 { "XdndStatus", F(atom.xdnd_status) },
1902 { "XdndFinished", F(atom.xdnd_finished) },
1903 { "XdndTypeList", F(atom.xdnd_type_list) },
1904 { "XdndActionCopy", F(atom.xdnd_action_copy) },
1905 { "WL_SURFACE_ID", F(atom.wl_surface_id) }
1909 xcb_xfixes_query_version_cookie_t xfixes_cookie;
1910 xcb_xfixes_query_version_reply_t *xfixes_reply;
1911 xcb_intern_atom_cookie_t cookies[ARRAY_LENGTH(atoms)];
1912 xcb_intern_atom_reply_t *reply;
1913 xcb_render_query_pict_formats_reply_t *formats_reply;
1914 xcb_render_query_pict_formats_cookie_t formats_cookie;
1915 xcb_render_pictforminfo_t *formats;
1918 xcb_prefetch_extension_data (wm->conn, &xcb_xfixes_id);
1919 xcb_prefetch_extension_data (wm->conn, &xcb_composite_id);
1921 formats_cookie = xcb_render_query_pict_formats(wm->conn);
1923 for (i = 0; i < ARRAY_LENGTH(atoms); i++)
1924 cookies[i] = xcb_intern_atom (wm->conn, 0,
1925 strlen(atoms[i].name),
1928 for (i = 0; i < ARRAY_LENGTH(atoms); i++) {
1929 reply = xcb_intern_atom_reply (wm->conn, cookies[i], NULL);
1930 *(xcb_atom_t *) ((char *) wm + atoms[i].offset) = reply->atom;
1934 wm->xfixes = xcb_get_extension_data(wm->conn, &xcb_xfixes_id);
1935 if (!wm->xfixes || !wm->xfixes->present)
1936 weston_log("xfixes not available\n");
1938 xfixes_cookie = xcb_xfixes_query_version(wm->conn,
1939 XCB_XFIXES_MAJOR_VERSION,
1940 XCB_XFIXES_MINOR_VERSION);
1941 xfixes_reply = xcb_xfixes_query_version_reply(wm->conn,
1942 xfixes_cookie, NULL);
1944 weston_log("xfixes version: %d.%d\n",
1945 xfixes_reply->major_version, xfixes_reply->minor_version);
1949 formats_reply = xcb_render_query_pict_formats_reply(wm->conn,
1951 if (formats_reply == NULL)
1954 formats = xcb_render_query_pict_formats_formats(formats_reply);
1955 for (i = 0; i < formats_reply->num_formats; i++) {
1956 if (formats[i].direct.red_mask != 0xff &&
1957 formats[i].direct.red_shift != 16)
1959 if (formats[i].type == XCB_RENDER_PICT_TYPE_DIRECT &&
1960 formats[i].depth == 24)
1961 wm->format_rgb = formats[i];
1962 if (formats[i].type == XCB_RENDER_PICT_TYPE_DIRECT &&
1963 formats[i].depth == 32 &&
1964 formats[i].direct.alpha_mask == 0xff &&
1965 formats[i].direct.alpha_shift == 24)
1966 wm->format_rgba = formats[i];
1969 free(formats_reply);
1973 weston_wm_create_wm_window(struct weston_wm *wm)
1975 static const char name[] = "Weston WM";
1977 wm->wm_window = xcb_generate_id(wm->conn);
1978 xcb_create_window(wm->conn,
1979 XCB_COPY_FROM_PARENT,
1985 XCB_WINDOW_CLASS_INPUT_OUTPUT,
1986 wm->screen->root_visual,
1989 xcb_change_property(wm->conn,
1990 XCB_PROP_MODE_REPLACE,
1992 wm->atom.net_supporting_wm_check,
1997 xcb_change_property(wm->conn,
1998 XCB_PROP_MODE_REPLACE,
2000 wm->atom.net_wm_name,
2001 wm->atom.utf8_string,
2003 strlen(name), name);
2005 xcb_change_property(wm->conn,
2006 XCB_PROP_MODE_REPLACE,
2008 wm->atom.net_supporting_wm_check,
2013 /* Claim the WM_S0 selection even though we don't suport
2014 * the --replace functionality. */
2015 xcb_set_selection_owner(wm->conn,
2018 XCB_TIME_CURRENT_TIME);
2020 xcb_set_selection_owner(wm->conn,
2022 wm->atom.net_wm_cm_s0,
2023 XCB_TIME_CURRENT_TIME);
2027 weston_wm_create(struct weston_xserver *wxs, int fd)
2029 struct weston_wm *wm;
2030 struct wl_event_loop *loop;
2031 xcb_screen_iterator_t s;
2033 xcb_atom_t supported[3];
2035 wm = zalloc(sizeof *wm);
2040 wm->window_hash = hash_table_create();
2041 if (wm->window_hash == NULL) {
2046 /* xcb_connect_to_fd takes ownership of the fd. */
2047 wm->conn = xcb_connect_to_fd(fd, NULL);
2048 if (xcb_connection_has_error(wm->conn)) {
2049 weston_log("xcb_connect_to_fd failed\n");
2051 hash_table_destroy(wm->window_hash);
2056 s = xcb_setup_roots_iterator(xcb_get_setup(wm->conn));
2057 wm->screen = s.data;
2059 loop = wl_display_get_event_loop(wxs->wl_display);
2061 wl_event_loop_add_fd(loop, fd,
2063 weston_wm_handle_event, wm);
2064 wl_event_source_check(wm->source);
2066 weston_wm_get_resources(wm);
2067 weston_wm_get_visual_and_colormap(wm);
2070 XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
2071 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT |
2072 XCB_EVENT_MASK_PROPERTY_CHANGE;
2073 xcb_change_window_attributes(wm->conn, wm->screen->root,
2074 XCB_CW_EVENT_MASK, values);
2076 xcb_composite_redirect_subwindows(wm->conn, wm->screen->root,
2077 XCB_COMPOSITE_REDIRECT_MANUAL);
2079 wm->theme = theme_create();
2081 supported[0] = wm->atom.net_wm_moveresize;
2082 supported[1] = wm->atom.net_wm_state;
2083 supported[2] = wm->atom.net_wm_state_fullscreen;
2084 xcb_change_property(wm->conn,
2085 XCB_PROP_MODE_REPLACE,
2087 wm->atom.net_supported,
2090 ARRAY_LENGTH(supported), supported);
2092 weston_wm_selection_init(wm);
2094 weston_wm_dnd_init(wm);
2096 xcb_flush(wm->conn);
2098 wm->create_surface_listener.notify = weston_wm_create_surface;
2099 wl_signal_add(&wxs->compositor->create_surface_signal,
2100 &wm->create_surface_listener);
2101 wm->activate_listener.notify = weston_wm_window_activate;
2102 wl_signal_add(&wxs->compositor->activate_signal,
2103 &wm->activate_listener);
2104 wm->transform_listener.notify = weston_wm_window_transform;
2105 wl_signal_add(&wxs->compositor->transform_signal,
2106 &wm->transform_listener);
2107 wm->kill_listener.notify = weston_wm_kill_client;
2108 wl_signal_add(&wxs->compositor->kill_signal,
2109 &wm->kill_listener);
2110 wl_list_init(&wm->unpaired_window_list);
2112 weston_wm_create_cursors(wm);
2113 weston_wm_window_set_cursor(wm, wm->screen->root, XWM_CURSOR_LEFT_PTR);
2115 /* Create wm window and take WM_S0 selection last, which
2116 * signals to Xwayland that we're done with setup. */
2117 weston_wm_create_wm_window(wm);
2119 weston_log("created wm, root %d\n", wm->screen->root);
2125 weston_wm_destroy(struct weston_wm *wm)
2127 /* FIXME: Free windows in hash. */
2128 hash_table_destroy(wm->window_hash);
2129 weston_wm_destroy_cursors(wm);
2130 xcb_disconnect(wm->conn);
2131 wl_event_source_remove(wm->source);
2132 wl_list_remove(&wm->selection_listener.link);
2133 wl_list_remove(&wm->activate_listener.link);
2134 wl_list_remove(&wm->kill_listener.link);
2135 wl_list_remove(&wm->transform_listener.link);
2140 static struct weston_wm_window *
2141 get_wm_window(struct weston_surface *surface)
2143 struct wl_listener *listener;
2145 listener = wl_signal_get(&surface->destroy_signal, surface_destroy);
2147 return container_of(listener, struct weston_wm_window,
2148 surface_destroy_listener);
2154 weston_wm_window_configure(void *data)
2156 struct weston_wm_window *window = data;
2157 struct weston_wm *wm = window->wm;
2159 int x, y, width, height;
2161 weston_wm_window_get_child_position(window, &x, &y);
2164 values[2] = window->width;
2165 values[3] = window->height;
2166 xcb_configure_window(wm->conn,
2168 XCB_CONFIG_WINDOW_X |
2169 XCB_CONFIG_WINDOW_Y |
2170 XCB_CONFIG_WINDOW_WIDTH |
2171 XCB_CONFIG_WINDOW_HEIGHT,
2174 weston_wm_window_get_frame_size(window, &width, &height);
2177 xcb_configure_window(wm->conn,
2179 XCB_CONFIG_WINDOW_WIDTH |
2180 XCB_CONFIG_WINDOW_HEIGHT,
2183 window->configure_source = NULL;
2185 weston_wm_window_schedule_repaint(window);
2189 send_configure(struct weston_surface *surface, int32_t width, int32_t height)
2191 struct weston_wm_window *window = get_wm_window(surface);
2192 struct weston_wm *wm = window->wm;
2193 struct theme *t = window->wm->theme;
2194 int vborder, hborder;
2196 if (window->decorate) {
2197 hborder = 2 * t->width;
2198 vborder = t->titlebar_height + t->width;
2204 if (width > hborder)
2205 window->width = width - hborder;
2209 if (height > vborder)
2210 window->height = height - vborder;
2215 frame_resize_inside(window->frame, window->width, window->height);
2217 if (window->configure_source)
2220 window->configure_source =
2221 wl_event_loop_add_idle(wm->server->loop,
2222 weston_wm_window_configure, window);
2225 static const struct weston_shell_client shell_client = {
2230 legacy_fullscreen(struct weston_wm *wm,
2231 struct weston_wm_window *window,
2232 struct weston_output **output_ret)
2234 struct weston_compositor *compositor = wm->server->compositor;
2235 struct weston_output *output;
2236 uint32_t minmax = PMinSize | PMaxSize;
2239 /* Heuristics for detecting legacy fullscreen windows... */
2241 wl_list_for_each(output, &compositor->output_list, link) {
2242 if (output->x == window->x &&
2243 output->y == window->y &&
2244 output->width == window->width &&
2245 output->height == window->height &&
2246 window->override_redirect) {
2247 *output_ret = output;
2252 if ((window->size_hints.flags & (USSize |PSize)) &&
2253 window->size_hints.width == output->width &&
2254 window->size_hints.height == output->height)
2256 if ((window->size_hints.flags & minmax) == minmax &&
2257 window->size_hints.min_width == output->width &&
2258 window->size_hints.min_height == output->height &&
2259 window->size_hints.max_width == output->width &&
2260 window->size_hints.max_height == output->height)
2263 if (matching_size && !window->decorate &&
2264 (window->size_hints.flags & (USPosition | PPosition)) &&
2265 window->size_hints.x == output->x &&
2266 window->size_hints.y == output->y) {
2267 *output_ret = output;
2276 xserver_map_shell_surface(struct weston_wm_window *window,
2277 struct weston_surface *surface)
2279 struct weston_wm *wm = window->wm;
2280 struct weston_shell_interface *shell_interface =
2281 &wm->server->compositor->shell_interface;
2282 struct weston_output *output;
2283 struct weston_wm_window *parent;
2285 weston_wm_window_read_properties(window);
2287 /* A weston_wm_window may have many different surfaces assigned
2288 * throughout its life, so we must make sure to remove the listener
2289 * from the old surface signal list. */
2290 if (window->surface)
2291 wl_list_remove(&window->surface_destroy_listener.link);
2293 window->surface = surface;
2294 window->surface_destroy_listener.notify = surface_destroy;
2295 wl_signal_add(&window->surface->destroy_signal,
2296 &window->surface_destroy_listener);
2298 weston_wm_window_schedule_repaint(window);
2300 if (!shell_interface->create_shell_surface)
2303 if (!shell_interface->get_primary_view)
2307 shell_interface->create_shell_surface(shell_interface->shell,
2310 window->view = shell_interface->get_primary_view(shell_interface->shell,
2314 shell_interface->set_title(window->shsurf, window->name);
2316 if (window->fullscreen) {
2317 window->saved_width = window->width;
2318 window->saved_height = window->height;
2319 shell_interface->set_fullscreen(window->shsurf,
2320 WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
2323 } else if (legacy_fullscreen(wm, window, &output)) {
2324 window->fullscreen = 1;
2325 shell_interface->set_fullscreen(window->shsurf,
2326 WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
2328 } else if (window->override_redirect) {
2329 shell_interface->set_xwayland(window->shsurf,
2332 WL_SHELL_SURFACE_TRANSIENT_INACTIVE);
2333 } else if (window->transient_for && window->transient_for->surface) {
2334 parent = window->transient_for;
2335 shell_interface->set_transient(window->shsurf,
2337 window->x - parent->x,
2338 window->y - parent->y, 0);
2340 shell_interface->set_toplevel(window->shsurf);