X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Frestore_layout.c;h=70eed523a6d5337689ccc79bc9f030d206af67ed;hb=1c4100ce5d8f9a7edc46f80f8a20ca50c6d97f8b;hp=e52f1567a3f191e87dc3a539199dc4e092528686;hpb=16ea766765a8e193b76a4e2b4f4756ff030b5882;p=i3%2Fi3 diff --git a/src/restore_layout.c b/src/restore_layout.c index e52f1567..70eed523 100644 --- a/src/restore_layout.c +++ b/src/restore_layout.c @@ -4,7 +4,7 @@ * vim:ts=4:sw=4:expandtab * * i3 - an improved dynamic tiling window manager - * © 2009-2013 Michael Stapelberg and contributors (see also: LICENSE) + * © 2009 Michael Stapelberg and contributors (see also: LICENSE) * * restore_layout.c: Everything for restored containers that is not pure state * parsing (which can be found in load_layout.c). @@ -35,6 +35,10 @@ static TAILQ_HEAD(state_head, placeholder_state) state_head = static xcb_connection_t *restore_conn; +static struct ev_io *xcb_watcher; +static struct ev_check *xcb_check; +static struct ev_prepare *xcb_prepare; + static void restore_handle_event(int type, xcb_generic_event_t *event); /* Documentation for these functions can be found in src/main.c, starting at xcb_got_event */ @@ -49,14 +53,14 @@ static void restore_xcb_check_cb(EV_P_ ev_check *w, int revents) { xcb_generic_event_t *event; if (xcb_connection_has_error(restore_conn)) { - // TODO: figure out how to reconnect with libev - ELOG("connection has an error\n"); + DLOG("restore X11 connection has an error, reconnecting\n"); + restore_connect(); return; } while ((event = xcb_poll_for_event(restore_conn)) != NULL) { if (event->response_type == 0) { - xcb_generic_error_t *error = (xcb_generic_error_t*)event; + xcb_generic_error_t *error = (xcb_generic_error_t *)event; DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n", error->sequence, error->error_code); free(event); @@ -80,14 +84,34 @@ static void restore_xcb_check_cb(EV_P_ ev_check *w, int revents) { * */ void restore_connect(void) { + if (restore_conn != NULL) { + /* This is not the initial connect, but a reconnect, most likely + * because our X11 connection was killed (e.g. by a user with xkill. */ + ev_io_stop(main_loop, xcb_watcher); + ev_check_stop(main_loop, xcb_check); + ev_prepare_stop(main_loop, xcb_prepare); + + placeholder_state *state; + while (!TAILQ_EMPTY(&state_head)) { + state = TAILQ_FIRST(&state_head); + TAILQ_REMOVE(&state_head, state, state); + free(state); + } + + free(restore_conn); + free(xcb_watcher); + free(xcb_check); + free(xcb_prepare); + } + int screen; restore_conn = xcb_connect(NULL, &screen); if (restore_conn == NULL || xcb_connection_has_error(restore_conn)) errx(EXIT_FAILURE, "Cannot open display\n"); - struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io)); - struct ev_check *xcb_check = scalloc(sizeof(struct ev_check)); - struct ev_prepare *xcb_prepare = scalloc(sizeof(struct ev_prepare)); + xcb_watcher = scalloc(1, sizeof(struct ev_io)); + xcb_check = scalloc(1, sizeof(struct ev_check)); + xcb_prepare = scalloc(1, sizeof(struct ev_prepare)); ev_io_init(xcb_watcher, restore_xcb_got_event, xcb_get_file_descriptor(restore_conn), EV_READ); ev_io_start(main_loop, xcb_watcher); @@ -100,30 +124,28 @@ void restore_connect(void) { } static void update_placeholder_contents(placeholder_state *state) { - // TODO: introduce color configuration for placeholder windows. - xcb_change_gc(restore_conn, state->gc, XCB_GC_FOREGROUND, (uint32_t[]) { config.client.background }); + xcb_change_gc(restore_conn, state->gc, XCB_GC_FOREGROUND, + (uint32_t[]){config.client.placeholder.background}); xcb_poly_fill_rectangle(restore_conn, state->pixmap, state->gc, 1, - (xcb_rectangle_t[]) { { 0, 0, state->rect.width, state->rect.height } }); + (xcb_rectangle_t[]){{0, 0, state->rect.width, state->rect.height}}); // TODO: make i3font functions per-connection, at least these two for now…? xcb_flush(restore_conn); xcb_aux_sync(restore_conn); - set_font_colors(state->gc, config.client.focused.background, 0); + set_font_colors(state->gc, config.client.placeholder.text, config.client.placeholder.background); Match *swallows; int n = 0; TAILQ_FOREACH(swallows, &(state->con->swallow_head), matches) { char *serialized = NULL; -#define APPEND_REGEX(re_name) do { \ - if (swallows->re_name != NULL) { \ - sasprintf(&serialized, "%s%s" #re_name "=\"%s\"", \ - (serialized ? serialized : "["), \ - (serialized ? " " : ""), \ - swallows->re_name->pattern); \ - } \ -} while (0) +#define APPEND_REGEX(re_name) \ + do { \ + if (swallows->re_name != NULL) { \ + sasprintf(&serialized, "%s%s" #re_name "=\"%s\"", (serialized ? serialized : "["), (serialized ? " " : ""), swallows->re_name->pattern); \ + } \ + } while (0) APPEND_REGEX(class); APPEND_REGEX(instance); @@ -139,7 +161,7 @@ static void update_placeholder_contents(placeholder_state *state) { DLOG("con %p (placeholder 0x%08x) line %d: %s\n", state->con, state->window, n, serialized); i3String *str = i3string_from_utf8(serialized); - draw_text(str, state->pixmap, state->gc, 2, (n * (config.font.height + 2)) + 2, state->rect.width - 2); + draw_text(str, state->pixmap, state->gc, NULL, 2, (n * (config.font.height + 2)) + 2, state->rect.width - 2); i3string_free(str); n++; free(serialized); @@ -150,33 +172,45 @@ static void update_placeholder_contents(placeholder_state *state) { int text_width = predict_text_width(line); int x = (state->rect.width / 2) - (text_width / 2); int y = (state->rect.height / 2) - (config.font.height / 2); - draw_text(line, state->pixmap, state->gc, x, y, text_width); + draw_text(line, state->pixmap, state->gc, NULL, x, y, text_width); i3string_free(line); xcb_flush(conn); xcb_aux_sync(conn); } static void open_placeholder_window(Con *con) { - if (con_is_leaf(con)) { + if (con_is_leaf(con) && + (con->window == NULL || con->window->id == XCB_NONE) && + !TAILQ_EMPTY(&(con->swallow_head)) && + con->type == CT_CON) { xcb_window_t placeholder = create_window( - restore_conn, - con->rect, - XCB_COPY_FROM_PARENT, - XCB_COPY_FROM_PARENT, - XCB_WINDOW_CLASS_INPUT_OUTPUT, - XCURSOR_CURSOR_POINTER, - true, - XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK, - (uint32_t[]){ - // TODO: use the background color as background pixel to avoid flickering - root_screen->white_pixel, - XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY, - }); - // TODO: set window title from con->name + restore_conn, + con->rect, + XCB_COPY_FROM_PARENT, + XCB_COPY_FROM_PARENT, + XCB_WINDOW_CLASS_INPUT_OUTPUT, + XCURSOR_CURSOR_POINTER, + true, + XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK, + (uint32_t[]){ + config.client.placeholder.background, + XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY, + }); + /* Make i3 not focus this window. */ + xcb_icccm_wm_hints_t hints; + xcb_icccm_wm_hints_set_none(&hints); + xcb_icccm_wm_hints_set_input(&hints, 0); + xcb_icccm_set_wm_hints(restore_conn, placeholder, &hints); + /* Set the same name as was stored in the layout file. While perhaps + * slightly confusing in the first instant, this brings additional + * clarity to which placeholder is waiting for which actual window. */ + if (con->name != NULL) + xcb_change_property(restore_conn, XCB_PROP_MODE_REPLACE, placeholder, + A__NET_WM_NAME, A_UTF8_STRING, 8, strlen(con->name), con->name); DLOG("Created placeholder window 0x%08x for leaf container %p / %s\n", placeholder, con, con->name); - placeholder_state *state = scalloc(sizeof(placeholder_state)); + placeholder_state *state = scalloc(1, sizeof(placeholder_state)); state->window = placeholder; state->con = con; state->rect = con->rect; @@ -184,7 +218,7 @@ static void open_placeholder_window(Con *con) { xcb_create_pixmap(restore_conn, root_depth, state->pixmap, state->window, state->rect.width, state->rect.height); state->gc = xcb_generate_id(restore_conn); - xcb_create_gc(restore_conn, state->gc, state->pixmap, XCB_GC_GRAPHICS_EXPOSURES, (uint32_t[]){ 0 }); + xcb_create_gc(restore_conn, state->gc, state->pixmap, XCB_GC_GRAPHICS_EXPOSURES, (uint32_t[]){0}); update_placeholder_contents(state); TAILQ_INSERT_TAIL(&state_head, state, state); @@ -192,7 +226,7 @@ static void open_placeholder_window(Con *con) { Match *temp_id = smalloc(sizeof(Match)); match_init(temp_id); temp_id->id = placeholder; - TAILQ_INSERT_TAIL(&(con->swallow_head), temp_id, matches); + TAILQ_INSERT_HEAD(&(con->swallow_head), temp_id, matches); } Con *child; @@ -223,6 +257,32 @@ void restore_open_placeholder_windows(Con *parent) { xcb_flush(restore_conn); } +/* + * Kill the placeholder window, if placeholder refers to a placeholder window. + * This function is called when manage.c puts a window into an existing + * container. In order not to leak resources, we need to destroy the window and + * all associated X11 objects (pixmap/gc). + * + */ +bool restore_kill_placeholder(xcb_window_t placeholder) { + placeholder_state *state; + TAILQ_FOREACH(state, &state_head, state) { + if (state->window != placeholder) + continue; + + xcb_destroy_window(restore_conn, state->window); + xcb_free_pixmap(restore_conn, state->pixmap); + xcb_free_gc(restore_conn, state->gc); + TAILQ_REMOVE(&state_head, state, state); + free(state); + DLOG("placeholder window 0x%08x destroyed.\n", placeholder); + return true; + } + + DLOG("0x%08x is not a placeholder window, ignoring.\n", placeholder); + return false; +} + static void expose_event(xcb_expose_event_t *event) { placeholder_state *state; TAILQ_FOREACH(state, &state_head, state) { @@ -270,7 +330,7 @@ static void configure_notify(xcb_configure_notify_event_t *event) { xcb_create_pixmap(restore_conn, root_depth, state->pixmap, state->window, state->rect.width, state->rect.height); state->gc = xcb_generate_id(restore_conn); - xcb_create_gc(restore_conn, state->gc, state->pixmap, XCB_GC_GRAPHICS_EXPOSURES, (uint32_t[]){ 0 }); + xcb_create_gc(restore_conn, state->gc, state->pixmap, XCB_GC_GRAPHICS_EXPOSURES, (uint32_t[]){0}); update_placeholder_contents(state); xcb_copy_area(restore_conn, state->pixmap, state->window, state->gc, @@ -282,14 +342,13 @@ static void configure_notify(xcb_configure_notify_event_t *event) { ELOG("Received ConfigureNotify for unknown window 0x%08x\n", event->window); } -// TODO: this event loop is not taken care of in the floating event handler static void restore_handle_event(int type, xcb_generic_event_t *event) { switch (type) { case XCB_EXPOSE: - expose_event((xcb_expose_event_t*)event); + expose_event((xcb_expose_event_t *)event); break; case XCB_CONFIGURE_NOTIFY: - configure_notify((xcb_configure_notify_event_t*)event); + configure_notify((xcb_configure_notify_event_t *)event); break; default: DLOG("Received unhandled X11 event of type %d\n", type);