2 * vim:ts=4:sw=4:expandtab
4 * i3 - an improved dynamic tiling window manager
5 * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
7 * restore_layout.c: Everything for restored containers that is not pure state
8 * parsing (which can be found in load_layout.c).
14 #ifdef I3_ASAN_ENABLED
15 #include <sanitizer/lsan_interface.h>
18 typedef struct placeholder_state {
19 /** The X11 placeholder window. */
21 /** The container to which this placeholder window belongs. */
24 /** Current size of the placeholder window (to detect size changes). */
27 /** The pixmap to render on (back buffer). */
29 /** The graphics context for “pixmap”. */
32 TAILQ_ENTRY(placeholder_state) state;
35 static TAILQ_HEAD(state_head, placeholder_state) state_head =
36 TAILQ_HEAD_INITIALIZER(state_head);
38 static xcb_connection_t *restore_conn;
40 static struct ev_io *xcb_watcher;
41 static struct ev_check *xcb_check;
42 static struct ev_prepare *xcb_prepare;
44 static void restore_handle_event(int type, xcb_generic_event_t *event);
46 /* Documentation for these functions can be found in src/main.c, starting at xcb_got_event */
47 static void restore_xcb_got_event(EV_P_ struct ev_io *w, int revents) {
50 static void restore_xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
51 xcb_flush(restore_conn);
54 static void restore_xcb_check_cb(EV_P_ ev_check *w, int revents) {
55 xcb_generic_event_t *event;
57 if (xcb_connection_has_error(restore_conn)) {
58 DLOG("restore X11 connection has an error, reconnecting\n");
63 while ((event = xcb_poll_for_event(restore_conn)) != NULL) {
64 if (event->response_type == 0) {
65 xcb_generic_error_t *error = (xcb_generic_error_t *)event;
66 DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
67 error->sequence, error->error_code);
72 /* Strip off the highest bit (set if the event is generated) */
73 int type = (event->response_type & 0x7F);
75 restore_handle_event(type, event);
82 * Opens a separate connection to X11 for placeholder windows when restoring
83 * layouts. This is done as a safety measure (users can xkill a placeholder
84 * window without killing their window manager) and for better isolation, both
85 * on the wire to X11 and thus also in the code.
88 void restore_connect(void) {
89 if (restore_conn != NULL) {
90 /* This is not the initial connect, but a reconnect, most likely
91 * because our X11 connection was killed (e.g. by a user with xkill. */
92 ev_io_stop(main_loop, xcb_watcher);
93 ev_check_stop(main_loop, xcb_check);
94 ev_prepare_stop(main_loop, xcb_prepare);
96 placeholder_state *state;
97 while (!TAILQ_EMPTY(&state_head)) {
98 state = TAILQ_FIRST(&state_head);
99 TAILQ_REMOVE(&state_head, state, state);
103 /* xcb_disconnect leaks memory in libxcb versions earlier than 1.11,
104 * but it’s the right function to call. See
105 * http://cgit.freedesktop.org/xcb/libxcb/commit/src/xcb_conn.c?id=4dcbfd77b
107 xcb_disconnect(restore_conn);
114 restore_conn = xcb_connect(NULL, &screen);
115 if (restore_conn == NULL || xcb_connection_has_error(restore_conn)) {
116 if (restore_conn != NULL) {
117 xcb_disconnect(restore_conn);
119 #ifdef I3_ASAN_ENABLED
120 __lsan_do_leak_check();
122 errx(EXIT_FAILURE, "Cannot open display\n");
125 xcb_watcher = scalloc(1, sizeof(struct ev_io));
126 xcb_check = scalloc(1, sizeof(struct ev_check));
127 xcb_prepare = scalloc(1, sizeof(struct ev_prepare));
129 ev_io_init(xcb_watcher, restore_xcb_got_event, xcb_get_file_descriptor(restore_conn), EV_READ);
130 ev_io_start(main_loop, xcb_watcher);
132 ev_check_init(xcb_check, restore_xcb_check_cb);
133 ev_check_start(main_loop, xcb_check);
135 ev_prepare_init(xcb_prepare, restore_xcb_prepare_cb);
136 ev_prepare_start(main_loop, xcb_prepare);
139 static void update_placeholder_contents(placeholder_state *state) {
140 xcb_change_gc(restore_conn, state->gc, XCB_GC_FOREGROUND,
141 (uint32_t[]){config.client.placeholder.background.colorpixel});
142 xcb_poly_fill_rectangle(restore_conn, state->pixmap, state->gc, 1,
143 (xcb_rectangle_t[]){{0, 0, state->rect.width, state->rect.height}});
145 // TODO: make i3font functions per-connection, at least these two for now…?
146 xcb_flush(restore_conn);
147 xcb_aux_sync(restore_conn);
149 set_font_colors(state->gc, config.client.placeholder.text, config.client.placeholder.background);
153 TAILQ_FOREACH(swallows, &(state->con->swallow_head), matches) {
154 char *serialized = NULL;
156 #define APPEND_REGEX(re_name) \
158 if (swallows->re_name != NULL) { \
159 sasprintf(&serialized, "%s%s" #re_name "=\"%s\"", (serialized ? serialized : "["), (serialized ? " " : ""), swallows->re_name->pattern); \
164 APPEND_REGEX(instance);
165 APPEND_REGEX(window_role);
168 if (serialized == NULL) {
169 DLOG("This swallows specification is not serializable?!\n");
173 sasprintf(&serialized, "%s]", serialized);
174 DLOG("con %p (placeholder 0x%08x) line %d: %s\n", state->con, state->window, n, serialized);
176 i3String *str = i3string_from_utf8(serialized);
177 draw_text(str, state->pixmap, state->gc, NULL, 2, (n * (config.font.height + 2)) + 2, state->rect.width - 2);
183 // TODO: render the watch symbol in a bigger font
184 i3String *line = i3string_from_utf8("⌚");
185 int text_width = predict_text_width(line);
186 int x = (state->rect.width / 2) - (text_width / 2);
187 int y = (state->rect.height / 2) - (config.font.height / 2);
188 draw_text(line, state->pixmap, state->gc, NULL, x, y, text_width);
194 static void open_placeholder_window(Con *con) {
195 if (con_is_leaf(con) &&
196 (con->window == NULL || con->window->id == XCB_NONE) &&
197 !TAILQ_EMPTY(&(con->swallow_head)) &&
198 con->type == CT_CON) {
199 xcb_window_t placeholder = create_window(
202 XCB_COPY_FROM_PARENT,
203 XCB_COPY_FROM_PARENT,
204 XCB_WINDOW_CLASS_INPUT_OUTPUT,
205 XCURSOR_CURSOR_POINTER,
207 XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK,
209 config.client.placeholder.background.colorpixel,
210 XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY,
212 /* Make i3 not focus this window. */
213 xcb_icccm_wm_hints_t hints;
214 xcb_icccm_wm_hints_set_none(&hints);
215 xcb_icccm_wm_hints_set_input(&hints, 0);
216 xcb_icccm_set_wm_hints(restore_conn, placeholder, &hints);
217 /* Set the same name as was stored in the layout file. While perhaps
218 * slightly confusing in the first instant, this brings additional
219 * clarity to which placeholder is waiting for which actual window. */
220 if (con->name != NULL)
221 xcb_change_property(restore_conn, XCB_PROP_MODE_REPLACE, placeholder,
222 A__NET_WM_NAME, A_UTF8_STRING, 8, strlen(con->name), con->name);
223 DLOG("Created placeholder window 0x%08x for leaf container %p / %s\n",
224 placeholder, con, con->name);
226 placeholder_state *state = scalloc(1, sizeof(placeholder_state));
227 state->window = placeholder;
229 state->rect = con->rect;
230 state->pixmap = xcb_generate_id(restore_conn);
231 xcb_create_pixmap(restore_conn, root_depth, state->pixmap,
232 state->window, state->rect.width, state->rect.height);
233 state->gc = xcb_generate_id(restore_conn);
234 xcb_create_gc(restore_conn, state->gc, state->pixmap, XCB_GC_GRAPHICS_EXPOSURES, (uint32_t[]){0});
235 update_placeholder_contents(state);
236 TAILQ_INSERT_TAIL(&state_head, state, state);
238 /* create temporary id swallow to match the placeholder */
239 Match *temp_id = smalloc(sizeof(Match));
241 temp_id->dock = M_DONTCHECK;
242 temp_id->id = placeholder;
243 TAILQ_INSERT_HEAD(&(con->swallow_head), temp_id, matches);
247 TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
248 open_placeholder_window(child);
250 TAILQ_FOREACH(child, &(con->floating_head), floating_windows) {
251 open_placeholder_window(child);
256 * Open placeholder windows for all children of parent. The placeholder window
257 * will vanish as soon as a real window is swallowed by the container. Until
258 * then, it exposes the criteria that must be fulfilled for a window to be
259 * swallowed by this container.
262 void restore_open_placeholder_windows(Con *parent) {
264 TAILQ_FOREACH(child, &(parent->nodes_head), nodes) {
265 open_placeholder_window(child);
267 TAILQ_FOREACH(child, &(parent->floating_head), floating_windows) {
268 open_placeholder_window(child);
271 xcb_flush(restore_conn);
275 * Kill the placeholder window, if placeholder refers to a placeholder window.
276 * This function is called when manage.c puts a window into an existing
277 * container. In order not to leak resources, we need to destroy the window and
278 * all associated X11 objects (pixmap/gc).
281 bool restore_kill_placeholder(xcb_window_t placeholder) {
282 placeholder_state *state;
283 TAILQ_FOREACH(state, &state_head, state) {
284 if (state->window != placeholder)
287 xcb_destroy_window(restore_conn, state->window);
288 xcb_free_pixmap(restore_conn, state->pixmap);
289 xcb_free_gc(restore_conn, state->gc);
290 TAILQ_REMOVE(&state_head, state, state);
292 DLOG("placeholder window 0x%08x destroyed.\n", placeholder);
296 DLOG("0x%08x is not a placeholder window, ignoring.\n", placeholder);
300 static void expose_event(xcb_expose_event_t *event) {
301 placeholder_state *state;
302 TAILQ_FOREACH(state, &state_head, state) {
303 if (state->window != event->window)
306 DLOG("refreshing window 0x%08x contents (con %p)\n", state->window, state->con);
308 /* Since we render to our pixmap on every change anyways, expose events
309 * only tell us that the X server lost (parts of) the window contents. We
310 * can handle that by copying the appropriate part from our pixmap to the
312 xcb_copy_area(restore_conn, state->pixmap, state->window, state->gc,
313 event->x, event->y, event->x, event->y,
314 event->width, event->height);
315 xcb_flush(restore_conn);
319 ELOG("Received ExposeEvent for unknown window 0x%08x\n", event->window);
323 * Window size has changed. Update the width/height, then recreate the back
324 * buffer pixmap and the accompanying graphics context and force an immediate
328 static void configure_notify(xcb_configure_notify_event_t *event) {
329 placeholder_state *state;
330 TAILQ_FOREACH(state, &state_head, state) {
331 if (state->window != event->window)
334 DLOG("ConfigureNotify: window 0x%08x has now width=%d, height=%d (con %p)\n",
335 state->window, event->width, event->height, state->con);
337 state->rect.width = event->width;
338 state->rect.height = event->height;
340 xcb_free_pixmap(restore_conn, state->pixmap);
341 xcb_free_gc(restore_conn, state->gc);
343 state->pixmap = xcb_generate_id(restore_conn);
344 xcb_create_pixmap(restore_conn, root_depth, state->pixmap,
345 state->window, state->rect.width, state->rect.height);
346 state->gc = xcb_generate_id(restore_conn);
347 xcb_create_gc(restore_conn, state->gc, state->pixmap, XCB_GC_GRAPHICS_EXPOSURES, (uint32_t[]){0});
349 update_placeholder_contents(state);
350 xcb_copy_area(restore_conn, state->pixmap, state->window, state->gc,
351 0, 0, 0, 0, state->rect.width, state->rect.height);
352 xcb_flush(restore_conn);
356 ELOG("Received ConfigureNotify for unknown window 0x%08x\n", event->window);
359 static void restore_handle_event(int type, xcb_generic_event_t *event) {
362 expose_event((xcb_expose_event_t *)event);
364 case XCB_CONFIGURE_NOTIFY:
365 configure_notify((xcb_configure_notify_event_t *)event);
368 DLOG("Received unhandled X11 event of type %d\n", type);