From: Kristian Høgsberg Date: Mon, 21 May 2012 21:12:41 +0000 (-0400) Subject: xwayland: Add window-manager.c X-Git-Tag: 20120702.1049~136 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=380deee3c7b18574d66511287bb01dde51027fbf;p=profile%2Fivi%2Fweston.git xwayland: Add window-manager.c Used mv instead of git mv to rename file... --- diff --git a/src/xwayland/window-manager.c b/src/xwayland/window-manager.c new file mode 100644 index 0000000..b05f4ac --- /dev/null +++ b/src/xwayland/window-manager.c @@ -0,0 +1,1236 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the copyright holders not be used in + * advertising or publicity pertaining to distribution of the software + * without specific, written prior permission. The copyright holders make + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER + * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF + * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "xwayland.h" + +#include "../../shared/cairo-util.h" +#include "../compositor.h" +#include "xserver-server-protocol.h" +#include "hash.h" + +struct motif_wm_hints { + uint32_t flags; + uint32_t functions; + uint32_t decorations; + int32_t input_mode; + uint32_t status; +}; + +#define MWM_HINTS_FUNCTIONS (1L << 0) +#define MWM_HINTS_DECORATIONS (1L << 1) +#define MWM_HINTS_INPUT_MODE (1L << 2) +#define MWM_HINTS_STATUS (1L << 3) + +#define MWM_FUNC_ALL (1L << 0) +#define MWM_FUNC_RESIZE (1L << 1) +#define MWM_FUNC_MOVE (1L << 2) +#define MWM_FUNC_MINIMIZE (1L << 3) +#define MWM_FUNC_MAXIMIZE (1L << 4) +#define MWM_FUNC_CLOSE (1L << 5) + +#define MWM_DECOR_ALL (1L << 0) +#define MWM_DECOR_BORDER (1L << 1) +#define MWM_DECOR_RESIZEH (1L << 2) +#define MWM_DECOR_TITLE (1L << 3) +#define MWM_DECOR_MENU (1L << 4) +#define MWM_DECOR_MINIMIZE (1L << 5) +#define MWM_DECOR_MAXIMIZE (1L << 6) + +#define MWM_INPUT_MODELESS 0 +#define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1 +#define MWM_INPUT_SYSTEM_MODAL 2 +#define MWM_INPUT_FULL_APPLICATION_MODAL 3 +#define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL + +#define MWM_TEAROFF_WINDOW (1L<<0) + +#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT 0 +#define _NET_WM_MOVERESIZE_SIZE_TOP 1 +#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT 2 +#define _NET_WM_MOVERESIZE_SIZE_RIGHT 3 +#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT 4 +#define _NET_WM_MOVERESIZE_SIZE_BOTTOM 5 +#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT 6 +#define _NET_WM_MOVERESIZE_SIZE_LEFT 7 +#define _NET_WM_MOVERESIZE_MOVE 8 /* movement only */ +#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD 9 /* size via keyboard */ +#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD 10 /* move via keyboard */ +#define _NET_WM_MOVERESIZE_CANCEL 11 /* cancel operation */ + + + +struct weston_wm_window { + struct weston_wm *wm; + xcb_window_t id; + xcb_window_t frame_id; + cairo_surface_t *cairo_surface; + struct weston_surface *surface; + struct shell_surface *shsurf; + struct wl_listener surface_destroy_listener; + struct wl_event_source *repaint_source; + int properties_dirty; + char *class; + char *name; + struct weston_wm_window *transient_for; + uint32_t protocols; + xcb_atom_t type; + int width, height; + int x, y; + int decorate; +}; + +static struct weston_wm_window * +get_wm_window(struct weston_surface *surface); + +const char * +get_atom_name(xcb_connection_t *c, xcb_atom_t atom) +{ + xcb_get_atom_name_cookie_t cookie; + xcb_get_atom_name_reply_t *reply; + xcb_generic_error_t *e; + static char buffer[64]; + + if (atom == XCB_ATOM_NONE) + return "None"; + + cookie = xcb_get_atom_name (c, atom); + reply = xcb_get_atom_name_reply (c, cookie, &e); + snprintf(buffer, sizeof buffer, "%.*s", + xcb_get_atom_name_name_length (reply), + xcb_get_atom_name_name (reply)); + free(reply); + + return buffer; +} + +void +dump_property(struct weston_wm *wm, xcb_atom_t property, + xcb_get_property_reply_t *reply) +{ + int32_t *incr_value; + const char *text_value, *name; + xcb_atom_t *atom_value; + int width, len; + uint32_t i; + + width = fprintf(stderr, " %s: ", get_atom_name(wm->conn, property)); + if (reply == NULL) { + fprintf(stderr, "(no reply)\n"); + return; + } + + width += fprintf(stderr, + "type %s, format %d, length %d (value_len %d): ", + get_atom_name(wm->conn, reply->type), + reply->format, + xcb_get_property_value_length(reply), + reply->value_len); + + if (reply->type == wm->atom.incr) { + incr_value = xcb_get_property_value(reply); + fprintf(stderr, "%d\n", *incr_value); + } else if (reply->type == wm->atom.utf8_string || + reply->type == wm->atom.string) { + text_value = xcb_get_property_value(reply); + if (reply->value_len > 40) + len = 40; + else + len = reply->value_len; + fprintf(stderr, "\"%.*s\"\n", len, text_value); + } else if (reply->type == XCB_ATOM_ATOM) { + atom_value = xcb_get_property_value(reply); + for (i = 0; i < reply->value_len; i++) { + name = get_atom_name(wm->conn, atom_value[i]); + if (width + strlen(name) + 2 > 78) { + fprintf(stderr, "\n "); + width = 4; + } else if (i > 0) { + width += fprintf(stderr, ", "); + } + + width += fprintf(stderr, "%s", name); + } + fprintf(stderr, "\n"); + } else { + fprintf(stderr, "huh?\n"); + } +} + +static void +dump_window_properties(struct weston_wm *wm, xcb_window_t window) +{ + xcb_list_properties_cookie_t list_cookie; + xcb_list_properties_reply_t *list_reply; + xcb_get_property_cookie_t property_cookie; + xcb_get_property_reply_t *property_reply; + xcb_atom_t *atoms; + int i, length; + + list_cookie = xcb_list_properties(wm->conn, window); + list_reply = xcb_list_properties_reply(wm->conn, list_cookie, NULL); + if (!list_reply) + /* Bad window, typically */ + return; + + length = xcb_list_properties_atoms_length(list_reply); + atoms = xcb_list_properties_atoms(list_reply); + + for (i = 0; i < length; i++) { + property_cookie = + xcb_get_property(wm->conn, + 0, /* delete */ + window, + atoms[i], + XCB_ATOM_ANY, + 0, 2048); + + property_reply = xcb_get_property_reply(wm->conn, + property_cookie, NULL); + dump_property(wm, atoms[i], property_reply); + + free(property_reply); + } + + free(list_reply); +} + +/* We reuse some predefined, but otherwise useles atoms */ +#define TYPE_WM_PROTOCOLS XCB_ATOM_CUT_BUFFER0 +#define TYPE_MOTIF_WM_HINTS XCB_ATOM_CUT_BUFFER1 + +static void +weston_wm_window_read_properties(struct weston_wm_window *window) +{ + struct weston_wm *wm = window->wm; + +#define F(field) offsetof(struct weston_wm_window, field) + const struct { + xcb_atom_t atom; + xcb_atom_t type; + int offset; + } props[] = { + { XCB_ATOM_WM_CLASS, XCB_ATOM_STRING, F(class) }, + { XCB_ATOM_WM_NAME, XCB_ATOM_STRING, F(name) }, + { XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, F(transient_for) }, + { wm->atom.wm_protocols, TYPE_WM_PROTOCOLS, F(protocols) }, + { wm->atom.net_wm_window_type, XCB_ATOM_ATOM, F(type) }, + { wm->atom.net_wm_name, XCB_ATOM_STRING, F(name) }, + { wm->atom.motif_wm_hints, TYPE_MOTIF_WM_HINTS, 0 }, + }; +#undef F + + xcb_get_property_cookie_t cookie[ARRAY_LENGTH(props)]; + xcb_get_property_reply_t *reply; + void *p; + uint32_t *xid; + xcb_atom_t *atom; + uint32_t i; + struct motif_wm_hints *hints; + + if (!window->properties_dirty) + return; + window->properties_dirty = 0; + + dump_window_properties(wm, window->id); + + for (i = 0; i < ARRAY_LENGTH(props); i++) + cookie[i] = xcb_get_property(wm->conn, + 0, /* delete */ + window->id, + props[i].atom, + XCB_ATOM_ANY, 0, 2048); + + window->decorate = 1; + for (i = 0; i < ARRAY_LENGTH(props); i++) { + reply = xcb_get_property_reply(wm->conn, cookie[i], NULL); + if (!reply) + /* Bad window, typically */ + continue; + if (reply->type == XCB_ATOM_NONE) { + /* No such property */ + free(reply); + continue; + } + + p = ((char *) window + props[i].offset); + + switch (props[i].type) { + case XCB_ATOM_STRING: + /* FIXME: We're using this for both string and + utf8_string */ + if (*(char **) p) + free(*(char **) p); + + *(char **) p = + strndup(xcb_get_property_value(reply), + xcb_get_property_value_length(reply)); + break; + case XCB_ATOM_WINDOW: + xid = xcb_get_property_value(reply); + *(struct weston_wm_window **) p = + hash_table_lookup(wm->window_hash, *xid); + break; + case XCB_ATOM_ATOM: + atom = xcb_get_property_value(reply); + *(xcb_atom_t *) p = *atom; + break; + case TYPE_WM_PROTOCOLS: + break; + case TYPE_MOTIF_WM_HINTS: + hints = xcb_get_property_value(reply); + if (hints->flags & MWM_HINTS_DECORATIONS) + window->decorate = hints->decorations > 0; + break; + default: + break; + } + free(reply); + } +} + +static void +weston_wm_handle_configure_request(struct weston_wm *wm, xcb_generic_event_t *event) +{ + xcb_configure_request_event_t *configure_request = + (xcb_configure_request_event_t *) event; + struct weston_wm_window *window; + uint32_t values[16]; + int i = 0; + + fprintf(stderr, "XCB_CONFIGURE_REQUEST (window %d) %d,%d @ %dx%d\n", + configure_request->window, + configure_request->x, configure_request->y, + configure_request->width, configure_request->height); + + window = hash_table_lookup(wm->window_hash, configure_request->window); + + if (configure_request->value_mask & XCB_CONFIG_WINDOW_X) + values[i++] = configure_request->x; + if (configure_request->value_mask & XCB_CONFIG_WINDOW_Y) + values[i++] = configure_request->y; + if (configure_request->value_mask & XCB_CONFIG_WINDOW_WIDTH) { + values[i++] = configure_request->width; + window->width = configure_request->width; + } + if (configure_request->value_mask & XCB_CONFIG_WINDOW_HEIGHT) { + values[i++] = configure_request->height; + window->height = configure_request->height; + } + + values[i++] = 0; /* XCB_CONFIG_WINDOW_BORDER_WIDTH */ + + if (configure_request->value_mask & XCB_CONFIG_WINDOW_SIBLING) + values[i++] = configure_request->sibling; + if (configure_request->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) + values[i++] = configure_request->stack_mode; + + xcb_configure_window(wm->conn, + configure_request->window, + configure_request->value_mask | + XCB_CONFIG_WINDOW_BORDER_WIDTH, values); +} + +static void +weston_wm_window_get_frame_size(struct weston_wm_window *window, + int *width, int *height) +{ + struct theme *t = window->wm->theme; + + if (window->decorate) { + *width = window->width + (t->margin + t->width) * 2; + *height = window->height + + t->margin * 2 + t->width + t->titlebar_height; + } else { + *width = window->width + t->margin * 2; + *height = window->height + t->margin * 2; + } +} + +static void +weston_wm_window_get_child_position(struct weston_wm_window *window, + int *x, int *y) +{ + struct theme *t = window->wm->theme; + + if (window->decorate) { + *x = t->margin + t->width; + *y = t->margin + t->titlebar_height; + } else { + *x = t->margin; + *y = t->margin; + } +} +static void +weston_wm_handle_configure_notify(struct weston_wm *wm, xcb_generic_event_t *event) +{ + xcb_configure_notify_event_t *configure_notify = + (xcb_configure_notify_event_t *) event; + struct weston_wm_window *window; + uint32_t values[2]; + int width, height; + + window = hash_table_lookup(wm->window_hash, configure_notify->window); + + fprintf(stderr, "XCB_CONFIGURE_NOTIFY (%s window %d) %d,%d @ %dx%d\n", + configure_notify->window == window->id ? "client" : "frame", + configure_notify->window, + configure_notify->x, configure_notify->y, + configure_notify->width, configure_notify->height); + + if (configure_notify->window != window->id) + return; + + window->x = configure_notify->x; + window->y = configure_notify->y; + window->width = configure_notify->width; + window->height = configure_notify->height; + + weston_wm_window_get_frame_size(window, &width, &height); + values[0] = width; + values[1] = height; + + xcb_configure_window(wm->conn, + window->frame_id, + XCB_CONFIG_WINDOW_WIDTH | + XCB_CONFIG_WINDOW_HEIGHT, + values); +} + +static void +weston_wm_activate(struct weston_wm *wm, + struct weston_wm_window *window, xcb_timestamp_t time) +{ + xcb_client_message_event_t client_message; + + client_message.response_type = XCB_CLIENT_MESSAGE; + client_message.format = 32; + client_message.window = window->id; + client_message.type = wm->atom.wm_protocols; + client_message.data.data32[0] = wm->atom.wm_take_focus; + client_message.data.data32[1] = XCB_TIME_CURRENT_TIME; + + xcb_send_event(wm->conn, 0, window->id, + XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, + (char *) &client_message); + + xcb_set_input_focus (wm->conn, + XCB_INPUT_FOCUS_POINTER_ROOT, window->id, time); +} + +static void +weston_wm_window_schedule_repaint(struct weston_wm_window *window); + +static void +weston_wm_window_activate(struct wl_listener *listener, void *data) +{ + struct weston_surface *surface = data; + struct weston_wm_window *window = get_wm_window(surface); + struct weston_wm *wm = window->wm; + + if (window) + weston_wm_activate(wm, window, XCB_TIME_CURRENT_TIME); + else + xcb_set_input_focus (wm->conn, + XCB_INPUT_FOCUS_POINTER_ROOT, + XCB_NONE, + XCB_TIME_CURRENT_TIME); + + if (wm->focus_window) + weston_wm_window_schedule_repaint(wm->focus_window); + wm->focus_window = window; + if (wm->focus_window) + weston_wm_window_schedule_repaint(wm->focus_window); +} + +static int +our_resource(struct weston_wm *wm, uint32_t id) +{ + const xcb_setup_t *setup; + + setup = xcb_get_setup(wm->conn); + + return (id & ~setup->resource_id_mask) == setup->resource_id_base; +} + +static void +weston_wm_handle_map_request(struct weston_wm *wm, xcb_generic_event_t *event) +{ + xcb_map_request_event_t *map_request = + (xcb_map_request_event_t *) event; + struct weston_wm_window *window; + uint32_t values[1]; + int x, y, width, height; + + if (our_resource(wm, map_request->window)) { + fprintf(stderr, "XCB_MAP_REQUEST (window %d, ours)\n", + map_request->window); + return; + } + + window = hash_table_lookup(wm->window_hash, map_request->window); + + weston_wm_window_read_properties(window); + + weston_wm_window_get_frame_size(window, &width, &height); + weston_wm_window_get_child_position(window, &x, &y); + + values[0] = + XCB_EVENT_MASK_KEY_PRESS | + XCB_EVENT_MASK_KEY_RELEASE | + XCB_EVENT_MASK_BUTTON_PRESS | + XCB_EVENT_MASK_BUTTON_RELEASE | + XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | + XCB_EVENT_MASK_EXPOSURE; + + window->frame_id = xcb_generate_id(wm->conn); + xcb_create_window(wm->conn, + XCB_COPY_FROM_PARENT, + window->frame_id, + wm->screen->root, + 0, 0, + width, height, + 0, + XCB_WINDOW_CLASS_INPUT_OUTPUT, + wm->screen->root_visual, + XCB_CW_EVENT_MASK, values); + xcb_reparent_window(wm->conn, window->id, window->frame_id, x, y); + + values[0] = 0; + xcb_configure_window(wm->conn, window->id, + XCB_CONFIG_WINDOW_BORDER_WIDTH, values); + + fprintf(stderr, "XCB_MAP_REQUEST (window %d, %p, frame %d)\n", + window->id, window, window->frame_id); + + xcb_change_save_set(wm->conn, XCB_SET_MODE_DELETE, window->id); + + xcb_map_window(wm->conn, map_request->window); + xcb_map_window(wm->conn, window->frame_id); + + window->cairo_surface = + cairo_xcb_surface_create_with_xrender_format(wm->conn, + wm->screen, + window->frame_id, + &wm->render_format, + width, height); + + hash_table_insert(wm->window_hash, window->frame_id, window); +} + +static void +weston_wm_handle_map_notify(struct weston_wm *wm, xcb_generic_event_t *event) +{ + xcb_map_notify_event_t *map_notify = (xcb_map_notify_event_t *) event; + + if (our_resource(wm, map_notify->window)) { + fprintf(stderr, "XCB_MAP_NOTIFY (window %d, ours)\n", + map_notify->window); + return; + } + + fprintf(stderr, "XCB_MAP_NOTIFY (window %d)\n", map_notify->window); +} + +static void +weston_wm_window_draw_decoration(void *data) +{ + struct weston_wm_window *window = data; + struct weston_wm *wm = window->wm; + struct theme *t = wm->theme; + cairo_t *cr; + int x, y, width, height; + const char *title; + uint32_t flags = 0; + + weston_wm_window_read_properties(window); + + window->repaint_source = NULL; + + weston_wm_window_get_frame_size(window, &width, &height); + weston_wm_window_get_child_position(window, &x, &y); + + cairo_xcb_surface_set_size(window->cairo_surface, width, height); + cr = cairo_create(window->cairo_surface); + + if (window->decorate) { + if (wm->focus_window == window) + flags |= THEME_FRAME_ACTIVE; + + if (window->name) + title = window->name; + else + title = "untitled"; + + theme_render_frame(t, cr, width, height, title, flags); + } else { + cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); + cairo_set_source_rgba(cr, 0, 0, 0, 0); + cairo_paint(cr); + + cairo_set_operator(cr, CAIRO_OPERATOR_OVER); + cairo_set_source_rgba(cr, 0, 0, 0, 0.45); + tile_mask(cr, t->shadow, 2, 2, width + 8, height + 8, 64, 64); + } + + cairo_destroy(cr); + + if (window->surface) { + /* We leave an extra pixel around the X window area to + * make sure we don't sample from the undefined alpha + * channel when filtering. */ + window->surface->opaque_rect[0] = + (double) (x - 1) / width; + window->surface->opaque_rect[1] = + (double) (x + window->width + 1) / width; + window->surface->opaque_rect[2] = + (double) (y - 1) / height; + window->surface->opaque_rect[3] = + (double) (y + window->height + 1) / height; + + pixman_region32_init_rect(&window->surface->input, + t->margin, t->margin, + width - 2 * t->margin, + height - 2 * t->margin); + } +} + +static void +weston_wm_window_schedule_repaint(struct weston_wm_window *window) +{ + struct weston_wm *wm = window->wm; + + if (window->frame_id == XCB_WINDOW_NONE || window->repaint_source) + return; + + window->repaint_source = + wl_event_loop_add_idle(wm->server->loop, + weston_wm_window_draw_decoration, + window); +} + +static void +weston_wm_handle_expose(struct weston_wm *wm, xcb_generic_event_t *event) +{ + struct weston_wm_window *window; + xcb_expose_event_t *expose = (xcb_expose_event_t *) event; + + window = hash_table_lookup(wm->window_hash, expose->window); + fprintf(stderr, "XCB_EXPOSE (window %d, title %s, surface %p)\n", + window->id, window->name, window->surface); + + weston_wm_window_schedule_repaint(window); +} + + +static void +weston_wm_handle_property_notify(struct weston_wm *wm, xcb_generic_event_t *event) +{ + xcb_property_notify_event_t *property_notify = + (xcb_property_notify_event_t *) event; + struct weston_wm_window *window; + + window = hash_table_lookup(wm->window_hash, property_notify->window); + if (window) + window->properties_dirty = 1; + + if (property_notify->atom == XCB_ATOM_WM_CLASS) { + fprintf(stderr, "wm_class changed\n"); + } else if (property_notify->atom == XCB_ATOM_WM_TRANSIENT_FOR) { + fprintf(stderr, "wm_transient_for changed\n"); + } else if (property_notify->atom == wm->atom.wm_protocols) { + fprintf(stderr, "wm_protocols changed\n"); + } else if (property_notify->atom == wm->atom.net_wm_name) { + fprintf(stderr, "_net_wm_name changed\n"); + weston_wm_window_schedule_repaint(window); + } else if (property_notify->atom == wm->atom.net_wm_user_time) { + fprintf(stderr, "_net_wm_user_time changed\n"); + } else if (property_notify->atom == wm->atom.net_wm_icon_name) { + fprintf(stderr, "_net_wm_icon_name changed\n"); + } else if (property_notify->atom == XCB_ATOM_WM_NAME) { + fprintf(stderr, "wm_name changed\n"); + weston_wm_window_schedule_repaint(window); + } else if (property_notify->atom == XCB_ATOM_WM_ICON_NAME) { + fprintf(stderr, "wm_icon_name changed\n"); + } else { + fprintf(stderr, "XCB_PROPERTY_NOTIFY: " + "unhandled property change: %s\n", + get_atom_name(wm->conn, property_notify->atom)); + } +} + +static void +weston_wm_handle_create_notify(struct weston_wm *wm, xcb_generic_event_t *event) +{ + xcb_create_notify_event_t *create_notify = + (xcb_create_notify_event_t *) event; + struct weston_wm_window *window; + uint32_t values[1]; + + fprintf(stderr, + "XCB_CREATE_NOTIFY (window %d, width %d, height %d%s%s)\n", + create_notify->window, + create_notify->width, create_notify->height, + create_notify->override_redirect ? ", override" : "", + our_resource(wm, create_notify->window) ? ", ours" : ""); + + if (our_resource(wm, create_notify->window)) + return; + + window = malloc(sizeof *window); + if (window == NULL) { + fprintf(stderr, "failed to allocate window\n"); + return; + } + + values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE; + xcb_change_window_attributes(wm->conn, create_notify->window, + XCB_CW_EVENT_MASK, values); + + memset(window, 0, sizeof *window); + window->wm = wm; + window->id = create_notify->window; + window->properties_dirty = 1; + + window->width = create_notify->width; + window->height = create_notify->height; + + hash_table_insert(wm->window_hash, window->id, window); +} + +static void +weston_wm_handle_destroy_notify(struct weston_wm *wm, xcb_generic_event_t *event) +{ + xcb_destroy_notify_event_t *destroy_notify = + (xcb_destroy_notify_event_t *) event; + struct weston_wm_window *window; + + if (our_resource(wm, destroy_notify->window)) { + fprintf(stderr, "XCB_DESTROY_NOTIFY, win %d (ours)\n", + destroy_notify->window); + return; + } + + window = hash_table_lookup(wm->window_hash, destroy_notify->window); + + fprintf(stderr, "XCB_DESTROY_NOTIFY, win %d (%p)\n", + destroy_notify->window, window); + + if (window->repaint_source) + wl_event_source_remove(window->repaint_source); + if (window->cairo_surface) + cairo_surface_destroy(window->cairo_surface); + + hash_table_remove(wm->window_hash, window->id); + hash_table_remove(wm->window_hash, window->frame_id); + xcb_destroy_window(wm->conn, window->frame_id); + if (window->surface) + wl_list_remove(&window->surface_destroy_listener.link); + free(window); +} + +static void +weston_wm_handle_client_message(struct weston_wm *wm, + xcb_generic_event_t *event) +{ + xcb_client_message_event_t *client_message = + (xcb_client_message_event_t *) event; + struct weston_shell_interface *shell_interface = + &wm->server->compositor->shell_interface; + struct weston_wm_window *window; + struct weston_seat *seat; + + window = hash_table_lookup(wm->window_hash, client_message->window); + + fprintf(stderr, "XCB_CLIENT_MESSAGE (%s %d %d %d %d %d)\n", + get_atom_name(wm->conn, client_message->type), + client_message->data.data32[0], + client_message->data.data32[1], + client_message->data.data32[2], + client_message->data.data32[3], + client_message->data.data32[4]); + + seat = wm->server->compositor->seat; + if (client_message->type == wm->atom.net_wm_moveresize && + client_message->data.data32[2] == _NET_WM_MOVERESIZE_MOVE && + seat->seat.pointer->button_count == 1 && + seat->seat.pointer->focus == &window->surface->surface) + shell_interface->move(window->shsurf, seat); +} + +static void +weston_wm_handle_button(struct weston_wm *wm, xcb_generic_event_t *event) +{ + xcb_button_press_event_t *button = (xcb_button_press_event_t *) event; + struct weston_shell_interface *shell_interface = + &wm->server->compositor->shell_interface; + struct weston_wm_window *window; + + fprintf(stderr, "XCB_BUTTON_%s (detail %d)\n", + button->response_type == XCB_BUTTON_PRESS ? + "PRESS" : "RELEASE", button->detail); + + window = hash_table_lookup(wm->window_hash, button->event); + if (button->response_type == XCB_BUTTON_PRESS && + button->detail == 1) + shell_interface->move(window->shsurf, + wm->server->compositor->seat); +} + +static int +weston_wm_handle_event(int fd, uint32_t mask, void *data) +{ + struct weston_wm *wm = data; + xcb_generic_event_t *event; + int count = 0; + + while (event = xcb_poll_for_event(wm->conn), event != NULL) { + if (weston_wm_handle_selection_event(wm, event)) { + fprintf(stderr, "handled by selection code\n"); + free(event); + count++; + continue; + } + + switch (event->response_type & ~0x80) { + case XCB_BUTTON_PRESS: + case XCB_BUTTON_RELEASE: + weston_wm_handle_button(wm, event); + break; + case XCB_EXPOSE: + weston_wm_handle_expose(wm, event); + break; + case XCB_CREATE_NOTIFY: + weston_wm_handle_create_notify(wm, event); + break; + case XCB_MAP_REQUEST: + weston_wm_handle_map_request(wm, event); + break; + case XCB_MAP_NOTIFY: + weston_wm_handle_map_notify(wm, event); + break; + case XCB_UNMAP_NOTIFY: + fprintf(stderr, "XCB_UNMAP_NOTIFY\n"); + break; + case XCB_CONFIGURE_REQUEST: + weston_wm_handle_configure_request(wm, event); + break; + case XCB_CONFIGURE_NOTIFY: + weston_wm_handle_configure_notify(wm, event); + break; + case XCB_DESTROY_NOTIFY: + weston_wm_handle_destroy_notify(wm, event); + break; + case XCB_MAPPING_NOTIFY: + fprintf(stderr, "XCB_MAPPING_NOTIFY\n"); + break; + case XCB_PROPERTY_NOTIFY: + weston_wm_handle_property_notify(wm, event); + break; + case XCB_CLIENT_MESSAGE: + weston_wm_handle_client_message(wm, event); + break; + } + + free(event); + count++; + } + + xcb_flush(wm->conn); + + return count; +} + +static void +wxs_wm_get_resources(struct weston_wm *wm) +{ + +#define F(field) offsetof(struct weston_wm, field) + + static const struct { const char *name; int offset; } atoms[] = { + { "WM_PROTOCOLS", F(atom.wm_protocols) }, + { "WM_TAKE_FOCUS", F(atom.wm_take_focus) }, + { "WM_DELETE_WINDOW", F(atom.wm_delete_window) }, + { "_NET_WM_NAME", F(atom.net_wm_name) }, + { "_NET_WM_ICON", F(atom.net_wm_icon) }, + { "_NET_WM_STATE", F(atom.net_wm_state) }, + { "_NET_WM_STATE_FULLSCREEN", F(atom.net_wm_state_fullscreen) }, + { "_NET_WM_USER_TIME", F(atom.net_wm_user_time) }, + { "_NET_WM_ICON_NAME", F(atom.net_wm_icon_name) }, + { "_NET_WM_WINDOW_TYPE", F(atom.net_wm_window_type) }, + + { "_NET_WM_WINDOW_TYPE_DESKTOP", F(atom.net_wm_window_type_desktop) }, + { "_NET_WM_WINDOW_TYPE_DOCK", F(atom.net_wm_window_type_dock) }, + { "_NET_WM_WINDOW_TYPE_TOOLBAR", F(atom.net_wm_window_type_toolbar) }, + { "_NET_WM_WINDOW_TYPE_MENU", F(atom.net_wm_window_type_menu) }, + { "_NET_WM_WINDOW_TYPE_UTILITY", F(atom.net_wm_window_type_utility) }, + { "_NET_WM_WINDOW_TYPE_SPLASH", F(atom.net_wm_window_type_splash) }, + { "_NET_WM_WINDOW_TYPE_DIALOG", F(atom.net_wm_window_type_dialog) }, + { "_NET_WM_WINDOW_TYPE_DROPDOWN", F(atom.net_wm_window_type_dropdown) }, + { "_NET_WM_WINDOW_TYPE_POPUP", F(atom.net_wm_window_type_popup) }, + { "_NET_WM_WINDOW_TYPE_TOOLTIP", F(atom.net_wm_window_type_tooltip) }, + { "_NET_WM_WINDOW_TYPE_NOTIFICATION", F(atom.net_wm_window_type_notification) }, + { "_NET_WM_WINDOW_TYPE_COMBO", F(atom.net_wm_window_type_combo) }, + { "_NET_WM_WINDOW_TYPE_DND", F(atom.net_wm_window_type_dnd) }, + { "_NET_WM_WINDOW_TYPE_NORMAL", F(atom.net_wm_window_type_normal) }, + + { "_NET_WM_MOVERESIZE", F(atom.net_wm_moveresize) }, + { "_NET_SUPPORTING_WM_CHECK", + F(atom.net_supporting_wm_check) }, + { "_NET_SUPPORTED", F(atom.net_supported) }, + { "_MOTIF_WM_HINTS", F(atom.motif_wm_hints) }, + { "CLIPBOARD", F(atom.clipboard) }, + { "TARGETS", F(atom.targets) }, + { "UTF8_STRING", F(atom.utf8_string) }, + { "_WL_SELECTION", F(atom.wl_selection) }, + { "INCR", F(atom.incr) }, + { "TIMESTAMP", F(atom.timestamp) }, + { "MULTIPLE", F(atom.multiple) }, + { "UTF8_STRING" , F(atom.utf8_string) }, + { "COMPOUND_TEXT", F(atom.compound_text) }, + { "TEXT", F(atom.text) }, + { "STRING", F(atom.string) }, + { "text/plain;charset=utf-8", F(atom.text_plain_utf8) }, + { "text/plain", F(atom.text_plain) }, + }; +#undef F + + xcb_xfixes_query_version_cookie_t xfixes_cookie; + xcb_xfixes_query_version_reply_t *xfixes_reply; + xcb_intern_atom_cookie_t cookies[ARRAY_LENGTH(atoms)]; + xcb_intern_atom_reply_t *reply; + xcb_render_query_pict_formats_reply_t *formats_reply; + xcb_render_query_pict_formats_cookie_t formats_cookie; + xcb_render_pictforminfo_t *formats; + uint32_t i; + + xcb_prefetch_extension_data (wm->conn, &xcb_xfixes_id); + + formats_cookie = xcb_render_query_pict_formats(wm->conn); + + for (i = 0; i < ARRAY_LENGTH(atoms); i++) + cookies[i] = xcb_intern_atom (wm->conn, 0, + strlen(atoms[i].name), + atoms[i].name); + + for (i = 0; i < ARRAY_LENGTH(atoms); i++) { + reply = xcb_intern_atom_reply (wm->conn, cookies[i], NULL); + *(xcb_atom_t *) ((char *) wm + atoms[i].offset) = reply->atom; + free(reply); + } + + wm->xfixes = xcb_get_extension_data(wm->conn, &xcb_xfixes_id); + if (!wm->xfixes || !wm->xfixes->present) + fprintf(stderr, "xfixes not available\n"); + + xfixes_cookie = xcb_xfixes_query_version(wm->conn, + XCB_XFIXES_MAJOR_VERSION, + XCB_XFIXES_MINOR_VERSION); + xfixes_reply = xcb_xfixes_query_version_reply(wm->conn, + xfixes_cookie, NULL); + + printf("xfixes version: %d.%d\n", + xfixes_reply->major_version, xfixes_reply->minor_version); + + free(xfixes_reply); + + formats_reply = xcb_render_query_pict_formats_reply(wm->conn, + formats_cookie, 0); + if (formats_reply == NULL) + return; + + formats = xcb_render_query_pict_formats_formats(formats_reply); + for (i = 0; i < formats_reply->length; i++) + if (formats[i].type == XCB_RENDER_PICT_TYPE_DIRECT && + formats[i].depth == 24) + wm->render_format = formats[i]; + + free(formats_reply); +} + +static void +weston_wm_create_wm_window(struct weston_wm *wm) +{ + static const char name[] = "Weston WM"; + + wm->wm_window = xcb_generate_id(wm->conn); + xcb_create_window(wm->conn, + XCB_COPY_FROM_PARENT, + wm->wm_window, + wm->screen->root, + 0, 0, + 10, 10, + 0, + XCB_WINDOW_CLASS_INPUT_OUTPUT, + wm->screen->root_visual, + 0, NULL); + + xcb_change_property(wm->conn, + XCB_PROP_MODE_REPLACE, + wm->wm_window, + wm->atom.net_supporting_wm_check, + XCB_ATOM_WINDOW, + 32, /* format */ + 1, &wm->wm_window); + + xcb_change_property(wm->conn, + XCB_PROP_MODE_REPLACE, + wm->wm_window, + wm->atom.net_wm_name, + wm->atom.utf8_string, + 8, /* format */ + strlen(name), name); + + xcb_change_property(wm->conn, + XCB_PROP_MODE_REPLACE, + wm->screen->root, + wm->atom.net_supporting_wm_check, + XCB_ATOM_WINDOW, + 32, /* format */ + 1, &wm->wm_window); + +} + +struct weston_wm * +weston_wm_create(struct weston_xserver *wxs) +{ + struct wl_seat *seat; + struct weston_wm *wm; + struct wl_event_loop *loop; + xcb_screen_iterator_t s; + uint32_t values[1], mask; + int sv[2]; + xcb_atom_t supported[1]; + + wm = malloc(sizeof *wm); + if (wm == NULL) + return NULL; + + memset(wm, 0, sizeof *wm); + wm->server = wxs; + wm->window_hash = hash_table_create(); + if (wm->window_hash == NULL) { + free(wm); + return NULL; + } + + if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) { + fprintf(stderr, "socketpair failed\n"); + hash_table_destroy(wm->window_hash); + free(wm); + return NULL; + } + + xserver_send_client(wxs->resource, sv[1]); + wl_client_flush(wxs->resource->client); + close(sv[1]); + + /* xcb_connect_to_fd takes ownership of the fd. */ + wm->conn = xcb_connect_to_fd(sv[0], NULL); + if (xcb_connection_has_error(wm->conn)) { + fprintf(stderr, "xcb_connect_to_fd failed\n"); + close(sv[0]); + hash_table_destroy(wm->window_hash); + free(wm); + return NULL; + } + + s = xcb_setup_roots_iterator(xcb_get_setup(wm->conn)); + wm->screen = s.data; + + loop = wl_display_get_event_loop(wxs->wl_display); + wm->source = + wl_event_loop_add_fd(loop, sv[0], + WL_EVENT_READABLE, + weston_wm_handle_event, wm); + wl_event_source_check(wm->source); + + wxs_wm_get_resources(wm); + + values[0] = + XCB_EVENT_MASK_STRUCTURE_NOTIFY | + XCB_EVENT_MASK_RESIZE_REDIRECT | + XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | + XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | + XCB_EVENT_MASK_PROPERTY_CHANGE; + xcb_change_window_attributes(wm->conn, wm->screen->root, + XCB_CW_EVENT_MASK, values); + wm->theme = theme_create(); + + weston_wm_create_wm_window(wm); + + supported[0] = wm->atom.net_wm_moveresize; + xcb_change_property(wm->conn, + XCB_PROP_MODE_REPLACE, + wm->screen->root, + wm->atom.net_supported, + XCB_ATOM_ATOM, + 32, /* format */ + ARRAY_LENGTH(supported), supported); + + wm->selection_request.requestor = XCB_NONE; + + wm->selection_window = xcb_generate_id(wm->conn); + xcb_create_window(wm->conn, + XCB_COPY_FROM_PARENT, + wm->selection_window, + wm->screen->root, + 0, 0, + 10, 10, + 0, + XCB_WINDOW_CLASS_INPUT_OUTPUT, + wm->screen->root_visual, + XCB_CW_EVENT_MASK, values); + + mask = + XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER | + XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY | + XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE; + + xcb_xfixes_select_selection_input(wm->conn, wm->selection_window, + wm->atom.clipboard, mask); + + xcb_flush(wm->conn); + + seat = &wxs->compositor->seat->seat; + wm->selection_listener.notify = weston_wm_set_selection; + wl_signal_add(&seat->selection_signal, &wm->selection_listener); + + wm->activate_listener.notify = weston_wm_window_activate; + wl_signal_add(&wxs->compositor->activate_signal, + &wm->activate_listener); + + fprintf(stderr, "created wm\n"); + + return wm; +} + +void +weston_wm_destroy(struct weston_wm *wm) +{ + /* FIXME: Free windows in hash. */ + hash_table_destroy(wm->window_hash); + xcb_disconnect(wm->conn); + wl_event_source_remove(wm->source); + wl_list_remove(&wm->selection_listener.link); + wl_list_remove(&wm->activate_listener.link); + + free(wm); +} + +static void +surface_destroy(struct wl_listener *listener, void *data) +{ + struct weston_wm_window *window = + container_of(listener, + struct weston_wm_window, surface_destroy_listener); + + fprintf(stderr, "surface for xid %d destroyed\n", window->id); +} + +static struct weston_wm_window * +get_wm_window(struct weston_surface *surface) +{ + struct wl_resource *resource = &surface->surface.resource; + struct wl_listener *listener; + + listener = wl_signal_get(&resource->destroy_signal, surface_destroy); + if (listener) + return container_of(listener, struct weston_wm_window, + surface_destroy_listener); + + return NULL; +} + +static void +xserver_map_shell_surface(struct weston_wm *wm, + struct weston_wm_window *window) +{ + struct weston_shell_interface *shell_interface = + &wm->server->compositor->shell_interface; + struct weston_wm_window *parent; + struct theme *t = window->wm->theme; + + if (!shell_interface->create_shell_surface) + return; + + window->shsurf = + shell_interface->create_shell_surface(shell_interface->shell, + window->surface); + + if (!window->transient_for) { + shell_interface->set_toplevel(window->shsurf); + return; + } + + parent = hash_table_lookup(wm->window_hash, window->transient_for->id); + shell_interface->set_transient(window->shsurf, parent->shsurf, + window->x - parent->x + t->margin + t->width, + window->y - parent->y + t->margin + t->titlebar_height, + WL_SHELL_SURFACE_TRANSIENT_INACTIVE); +} + +static void +xserver_set_window_id(struct wl_client *client, struct wl_resource *resource, + struct wl_resource *surface_resource, uint32_t id) +{ + struct weston_xserver *wxs = resource->data; + struct weston_wm *wm = wxs->wm; + struct wl_surface *surface = surface_resource->data; + struct weston_wm_window *window; + + if (client != wxs->client) + return; + + window = hash_table_lookup(wm->window_hash, id); + if (window == NULL) { + fprintf(stderr, "set_window_id for unknown window %d\n", id); + return; + } + + fprintf(stderr, "set_window_id %d for surface %p\n", id, surface); + + weston_wm_window_read_properties(window); + + window->surface = (struct weston_surface *) surface; + window->surface_destroy_listener.notify = surface_destroy; + wl_signal_add(&surface->resource.destroy_signal, + &window->surface_destroy_listener); + + weston_wm_window_schedule_repaint(window); + xserver_map_shell_surface(wm, window); +} + +const struct xserver_interface xserver_implementation = { + xserver_set_window_id +};