2 #define I3__FILE__ "restore_layout.c"
4 * vim:ts=4:sw=4:expandtab
6 * i3 - an improved dynamic tiling window manager
7 * © 2009-2013 Michael Stapelberg and contributors (see also: LICENSE)
9 * restore_layout.c: Everything for restored containers that is not pure state
10 * parsing (which can be found in load_layout.c).
16 typedef struct placeholder_state {
17 /** The X11 placeholder window. */
19 /** The container to which this placeholder window belongs. */
22 /** Current size of the placeholder window (to detect size changes). */
25 /** The pixmap to render on (back buffer). */
27 /** The graphics context for “pixmap”. */
30 TAILQ_ENTRY(placeholder_state) state;
33 static TAILQ_HEAD(state_head, placeholder_state) state_head =
34 TAILQ_HEAD_INITIALIZER(state_head);
36 static xcb_connection_t *restore_conn;
38 static void restore_handle_event(int type, xcb_generic_event_t *event);
40 /* Documentation for these functions can be found in src/main.c, starting at xcb_got_event */
41 static void restore_xcb_got_event(EV_P_ struct ev_io *w, int revents) {
44 static void restore_xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
45 xcb_flush(restore_conn);
48 static void restore_xcb_check_cb(EV_P_ ev_check *w, int revents) {
49 xcb_generic_event_t *event;
51 if (xcb_connection_has_error(restore_conn)) {
52 // TODO: figure out how to reconnect with libev
53 ELOG("connection has an error\n");
57 while ((event = xcb_poll_for_event(restore_conn)) != NULL) {
58 if (event->response_type == 0) {
59 xcb_generic_error_t *error = (xcb_generic_error_t*)event;
60 DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
61 error->sequence, error->error_code);
66 /* Strip off the highest bit (set if the event is generated) */
67 int type = (event->response_type & 0x7F);
69 restore_handle_event(type, event);
76 * Opens a separate connection to X11 for placeholder windows when restoring
77 * layouts. This is done as a safety measure (users can xkill a placeholder
78 * window without killing their window manager) and for better isolation, both
79 * on the wire to X11 and thus also in the code.
82 void restore_connect(void) {
84 restore_conn = xcb_connect(NULL, &screen);
85 if (restore_conn == NULL || xcb_connection_has_error(restore_conn))
86 errx(EXIT_FAILURE, "Cannot open display\n");
88 struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io));
89 struct ev_check *xcb_check = scalloc(sizeof(struct ev_check));
90 struct ev_prepare *xcb_prepare = scalloc(sizeof(struct ev_prepare));
92 ev_io_init(xcb_watcher, restore_xcb_got_event, xcb_get_file_descriptor(restore_conn), EV_READ);
93 ev_io_start(main_loop, xcb_watcher);
95 ev_check_init(xcb_check, restore_xcb_check_cb);
96 ev_check_start(main_loop, xcb_check);
98 ev_prepare_init(xcb_prepare, restore_xcb_prepare_cb);
99 ev_prepare_start(main_loop, xcb_prepare);
102 static void update_placeholder_contents(placeholder_state *state) {
103 // TODO: introduce color configuration for placeholder windows.
104 xcb_change_gc(restore_conn, state->gc, XCB_GC_FOREGROUND, (uint32_t[]) { config.client.background });
105 xcb_poly_fill_rectangle(restore_conn, state->pixmap, state->gc, 1,
106 (xcb_rectangle_t[]) { { 0, 0, state->rect.width, state->rect.height } });
108 // TODO: make i3font functions per-connection, at least these two for now…?
109 xcb_flush(restore_conn);
110 xcb_aux_sync(restore_conn);
112 // TODO: actually represent the criteria, most likely just line by line from (0, 0)
113 set_font_colors(state->gc, config.client.focused.background, 0);
114 i3String *line = i3string_from_utf8("⌚");
115 int text_width = predict_text_width(line);
116 int x = (state->rect.width / 2) - (text_width / 2);
117 int y = (state->rect.height / 2) - (config.font.height / 2);
118 draw_text(line, state->pixmap, state->gc, x, y, text_width);
124 static void open_placeholder_window(Con *con) {
125 if (con_is_leaf(con)) {
126 xcb_window_t placeholder = create_window(
129 XCB_COPY_FROM_PARENT,
130 XCB_COPY_FROM_PARENT,
131 XCB_WINDOW_CLASS_INPUT_OUTPUT,
132 XCURSOR_CURSOR_POINTER,
134 XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK,
136 // TODO: use the background color as background pixel to avoid flickering
137 root_screen->white_pixel,
138 XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY,
140 // TODO: set window title from con->name
141 DLOG("Created placeholder window 0x%08x for leaf container %p / %s\n",
142 placeholder, con, con->name);
144 placeholder_state *state = scalloc(sizeof(placeholder_state));
145 state->window = placeholder;
147 state->rect = con->rect;
148 state->pixmap = xcb_generate_id(restore_conn);
149 // TODO: get rid of hardcoded 24
150 xcb_create_pixmap(restore_conn, 24, state->pixmap,
151 state->window, state->rect.width, state->rect.height);
152 state->gc = xcb_generate_id(restore_conn);
153 xcb_create_gc(restore_conn, state->gc, state->pixmap, XCB_GC_GRAPHICS_EXPOSURES, (uint32_t[]){ 0 });
154 update_placeholder_contents(state);
155 TAILQ_INSERT_TAIL(&state_head, state, state);
157 /* create temporary id swallow to match the placeholder */
158 Match *temp_id = smalloc(sizeof(Match));
160 temp_id->id = placeholder;
161 TAILQ_INSERT_TAIL(&(con->swallow_head), temp_id, matches);
165 TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
166 open_placeholder_window(child);
168 TAILQ_FOREACH(child, &(con->floating_head), floating_windows) {
169 open_placeholder_window(child);
174 * Open placeholder windows for all children of parent. The placeholder window
175 * will vanish as soon as a real window is swallowed by the container. Until
176 * then, it exposes the criteria that must be fulfilled for a window to be
177 * swallowed by this container.
180 void restore_open_placeholder_windows(Con *parent) {
182 TAILQ_FOREACH(child, &(parent->nodes_head), nodes) {
183 open_placeholder_window(child);
185 TAILQ_FOREACH(child, &(parent->floating_head), floating_windows) {
186 open_placeholder_window(child);
189 xcb_flush(restore_conn);
192 static void expose_event(xcb_expose_event_t *event) {
193 placeholder_state *state;
194 TAILQ_FOREACH(state, &state_head, state) {
195 if (state->window != event->window)
198 DLOG("refreshing window 0x%08x contents (con %p)\n", state->window, state->con);
200 /* Since we render to our pixmap on every change anyways, expose events
201 * only tell us that the X server lost (parts of) the window contents. We
202 * can handle that by copying the appropriate part from our pixmap to the
204 xcb_copy_area(restore_conn, state->pixmap, state->window, state->gc,
205 event->x, event->y, event->x, event->y,
206 event->width, event->height);
207 xcb_flush(restore_conn);
211 ELOG("Received ExposeEvent for unknown window 0x%08x\n", event->window);
215 * Window size has changed. Update the width/height, then recreate the back
216 * buffer pixmap and the accompanying graphics context and force an immediate
220 static void configure_notify(xcb_configure_notify_event_t *event) {
221 placeholder_state *state;
222 TAILQ_FOREACH(state, &state_head, state) {
223 if (state->window != event->window)
226 DLOG("ConfigureNotify: window 0x%08x has now width=%d, height=%d (con %p)\n",
227 state->window, event->width, event->height, state->con);
229 state->rect.width = event->width;
230 state->rect.height = event->height;
232 xcb_free_pixmap(restore_conn, state->pixmap);
233 xcb_free_gc(restore_conn, state->gc);
235 state->pixmap = xcb_generate_id(restore_conn);
236 // TODO: get rid of hardcoded 24
237 xcb_create_pixmap(restore_conn, 24, state->pixmap,
238 state->window, state->rect.width, state->rect.height);
239 state->gc = xcb_generate_id(restore_conn);
240 xcb_create_gc(restore_conn, state->gc, state->pixmap, XCB_GC_GRAPHICS_EXPOSURES, (uint32_t[]){ 0 });
242 update_placeholder_contents(state);
243 xcb_copy_area(restore_conn, state->pixmap, state->window, state->gc,
244 0, 0, 0, 0, state->rect.width, state->rect.height);
245 xcb_flush(restore_conn);
249 ELOG("Received ConfigureNotify for unknown window 0x%08x\n", event->window);
252 // TODO: this event loop is not taken care of in the floating event handler
253 static void restore_handle_event(int type, xcb_generic_event_t *event) {
256 expose_event((xcb_expose_event_t*)event);
258 case XCB_CONFIGURE_NOTIFY:
259 configure_notify((xcb_configure_notify_event_t*)event);
262 DLOG("Received unhandled X11 event of type %d\n", type);