X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fx.c;h=78c6de33b243d8735af613b19719719364f70a7a;hb=71ccb4bef2850bd5beab8a4ef4669bf53b5a9781;hp=070fae91b1e74097e9caf910099ad7c4302aec41;hpb=5a345db18bc92e23a54db16840412cd74b618d1d;p=i3%2Fi3 diff --git a/src/x.c b/src/x.c index 070fae91..78c6de33 100644 --- a/src/x.c +++ b/src/x.c @@ -1,8 +1,10 @@ +#undef I3__FILE__ +#define I3__FILE__ "x.c" /* * vim:ts=4:sw=4:expandtab * * i3 - an improved dynamic tiling window manager - * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE) + * © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE) * * x.c: Interface to X11, transfers our in-memory state to X11 (see also * render.c). Basically a big state machine. @@ -85,23 +87,60 @@ static con_state *state_for_frame(xcb_window_t window) { * every container from con_new(). * */ -void x_con_init(Con *con) { +void x_con_init(Con *con, uint16_t depth) { /* TODO: maybe create the window when rendering first? we could then even * get the initial geometry right */ uint32_t mask = 0; - uint32_t values[2]; - - /* our own frames should not be managed */ - mask |= XCB_CW_OVERRIDE_REDIRECT; - values[0] = 1; - - /* see include/xcb.h for the FRAME_EVENT_MASK */ - mask |= XCB_CW_EVENT_MASK; - values[1] = FRAME_EVENT_MASK & ~XCB_EVENT_MASK_ENTER_WINDOW; + uint32_t values[5]; + + xcb_visualid_t visual = XCB_COPY_FROM_PARENT; + xcb_colormap_t win_colormap = XCB_NONE; + if (depth != root_depth && depth != XCB_COPY_FROM_PARENT) { + /* For custom visuals, we need to create a colormap before creating + * this window. It will be freed directly after creating the window. */ + visual = get_visualid_by_depth(depth); + win_colormap = xcb_generate_id(conn); + xcb_create_colormap_checked(conn, XCB_COLORMAP_ALLOC_NONE, win_colormap, root, visual); + + /* We explicitly set a background color and border color (even though we + * don’t even have a border) because the X11 server requires us to when + * using 32 bit color depths, see + * http://stackoverflow.com/questions/3645632 */ + mask |= XCB_CW_BACK_PIXEL; + values[0] = root_screen->black_pixel; + + mask |= XCB_CW_BORDER_PIXEL; + values[1] = root_screen->black_pixel; + + /* our own frames should not be managed */ + mask |= XCB_CW_OVERRIDE_REDIRECT; + values[2] = 1; + + /* see include/xcb.h for the FRAME_EVENT_MASK */ + mask |= XCB_CW_EVENT_MASK; + values[3] = FRAME_EVENT_MASK & ~XCB_EVENT_MASK_ENTER_WINDOW; + + mask |= XCB_CW_COLORMAP; + values[4] = win_colormap; + } else { + /* our own frames should not be managed */ + mask = XCB_CW_OVERRIDE_REDIRECT; + values[0] = 1; + + /* see include/xcb.h for the FRAME_EVENT_MASK */ + mask |= XCB_CW_EVENT_MASK; + values[1] = FRAME_EVENT_MASK & ~XCB_EVENT_MASK_ENTER_WINDOW; + + mask |= XCB_CW_COLORMAP; + values[2] = colormap; + } Rect dims = { -15, -15, 10, 10 }; - con->frame = create_window(conn, dims, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCURSOR_CURSOR_POINTER, false, mask, values); + con->frame = create_window(conn, dims, depth, visual, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCURSOR_CURSOR_POINTER, false, mask, values); + + if (win_colormap != XCB_NONE) + xcb_free_colormap(conn, win_colormap); struct con_state *state = scalloc(sizeof(struct con_state)); state->id = con->frame; @@ -262,16 +301,20 @@ void x_window_kill(xcb_window_t window, kill_window_t kill_window) { void x_draw_decoration(Con *con) { Con *parent = con->parent; bool leaf = con_is_leaf(con); + /* This code needs to run for: * • leaf containers * • non-leaf containers which are in a stacked/tabbed container * * It does not need to run for: + * • direct children of outputs or dockareas * • floating containers (they don’t have a decoration) */ if ((!leaf && parent->layout != L_STACKED && parent->layout != L_TABBED) || + parent->type == CT_OUTPUT || + parent->type == CT_DOCKAREA || con->type == CT_FLOATING_CON) return; @@ -307,6 +350,7 @@ void x_draw_decoration(Con *con) { p->con_deco_rect = con->deco_rect; p->background = config.client.background; p->con_is_leaf = con_is_leaf(con); + p->parent_orientation = con_orientation(parent); if (con->deco_render_params != NULL && (con->window == NULL || !con->window->name_x_changed) && @@ -359,6 +403,10 @@ void x_draw_decoration(Con *con) { /* 3: draw a rectangle in border color around the client */ if (p->border_style != BS_NONE && p->con_is_leaf) { + /* We might hide some borders adjacent to the screen-edge */ + adjacent_t borders_to_hide = ADJ_NONE; + borders_to_hide = con_adjacent_borders(con) & config.hide_edge_borders; + Rect br = con_border_style_rect(con); #if 0 DLOG("con->rect spans %d x %d\n", con->rect.width, con->rect.height); @@ -371,20 +419,43 @@ void x_draw_decoration(Con *con) { * rectangle because some childs are not freely resizable and we want * their background color to "shine through". */ xcb_change_gc(conn, con->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]){ p->color->background }); - xcb_rectangle_t borders[] = { - { 0, 0, br.x, r->height }, - { 0, r->height + br.height + br.y, r->width, r->height }, - { r->width + br.width + br.x, 0, r->width, r->height } - }; - xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 3, borders); + if (!(borders_to_hide & ADJ_LEFT_SCREEN_EDGE)) { + xcb_rectangle_t leftline = { 0, 0, br.x, r->height }; + xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, &leftline); + } + if (!(borders_to_hide & ADJ_RIGHT_SCREEN_EDGE)) { + xcb_rectangle_t rightline = { r->width + br.width + br.x, 0, r->width, r->height }; + xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, &rightline); + } + if (!(borders_to_hide & ADJ_LOWER_SCREEN_EDGE)) { + xcb_rectangle_t bottomline = { 0, r->height + br.height + br.y, r->width, r->height }; + xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, &bottomline); + } /* 1pixel border needs an additional line at the top */ - if (p->border_style == BS_1PIXEL) { + if (p->border_style == BS_PIXEL && !(borders_to_hide & ADJ_UPPER_SCREEN_EDGE)) { xcb_rectangle_t topline = { br.x, 0, con->rect.width + br.width + br.x, br.y }; xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, &topline); } + + /* Highlight the side of the border at which the next window will be + * opened if we are rendering a single window within a split container + * (which is undistinguishable from a single window outside a split + * container otherwise. */ + if (TAILQ_NEXT(con, nodes) == NULL && + TAILQ_PREV(con, nodes_head, nodes) == NULL && + con->parent->type != CT_FLOATING_CON) { + xcb_change_gc(conn, con->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]){ p->color->indicator }); + if (p->parent_orientation == HORIZ) + xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, (xcb_rectangle_t[]){ + { r->width + br.width + br.x, br.y, r->width, r->height + br.height } }); + else + xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, 1, (xcb_rectangle_t[]){ + { br.x, r->height + br.height + br.y, r->width - (2 * br.x), r->height } }); + } + } - /* if this is a borderless/1pixel window, we don’t * need to render the + /* if this is a borderless/1pixel window, we don’t need to render the * decoration. */ if (p->border_style != BS_NORMAL) goto copy_pixmaps; @@ -397,12 +468,20 @@ void x_draw_decoration(Con *con) { /* 5: draw two unconnected lines in border color */ xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]){ p->color->border }); Rect *dr = &(con->deco_rect); + int deco_diff_l = 2; + int deco_diff_r = 2; + if (parent->layout == L_TABBED) { + if (TAILQ_PREV(con, nodes_head, nodes) != NULL) + deco_diff_l = 0; + if (TAILQ_NEXT(con, nodes) != NULL) + deco_diff_r = 0; + } xcb_segment_t segments[] = { { dr->x, dr->y, dr->x + dr->width - 1, dr->y }, - { dr->x + 2, dr->y + dr->height - 1, - dr->x + dr->width - 3, dr->y + dr->height - 1 } + { dr->x + deco_diff_l, dr->y + dr->height - 1, + dr->x - deco_diff_r + dr->width - 1, dr->y + dr->height - 1 } }; xcb_poly_segment(conn, parent->pixmap, parent->pm_gc, 2, segments); @@ -411,16 +490,27 @@ void x_draw_decoration(Con *con) { int text_offset_y = (con->deco_rect.height - config.font.height) / 2; struct Window *win = con->window; - if (win == NULL || win->name_x == NULL) { - /* this is a non-leaf container, we need to make up a good description */ - // TODO: use a good description instead of just "another container" - draw_text("another container", strlen("another container"), false, + if (win == NULL) { + /* we have a split container which gets a representation + * of its children as title + */ + char *title; + char *tree = con_get_tree_representation(con); + sasprintf(&title, "i3: %s", tree); + free(tree); + + draw_text_ascii(title, parent->pixmap, parent->pm_gc, con->deco_rect.x + 2, con->deco_rect.y + text_offset_y, con->deco_rect.width - 2); + free(title); + goto copy_pixmaps; } + if (win->name == NULL) + goto copy_pixmaps; + int indent_level = 0, indent_mult = 0; Con *il_parent = parent; @@ -438,11 +528,34 @@ void x_draw_decoration(Con *con) { //DLOG("indent_level = %d, indent_mult = %d\n", indent_level, indent_mult); int indent_px = (indent_level * 5) * indent_mult; - draw_text(win->name_x, win->name_len, win->uses_net_wm_name, + draw_text(win->name, parent->pixmap, parent->pm_gc, con->deco_rect.x + 2 + indent_px, con->deco_rect.y + text_offset_y, con->deco_rect.width - 2 - indent_px); + /* Since we don’t clip the text at all, it might in some cases be painted + * on the border pixels on the right side of a window. Therefore, we draw + * the right border again after rendering the text (and the unconnected + * lines in border color). */ + + /* Draw a separator line after every tab (except the last one), so that + * tabs can be easily distinguished. */ + if (parent->layout == L_TABBED && TAILQ_NEXT(con, nodes) != NULL) { + xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]){ p->color->border }); + } else { + xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]){ p->color->background }); + } + xcb_poly_line(conn, XCB_COORD_MODE_ORIGIN, parent->pixmap, parent->pm_gc, 4, + (xcb_point_t[]){ + { dr->x + dr->width - 1, dr->y }, + { dr->x + dr->width - 1, dr->y + dr->height }, + { dr->x + dr->width - 2, dr->y }, + { dr->x + dr->width - 2, dr->y + dr->height } + }); + + xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]){ p->color->border }); + xcb_poly_segment(conn, parent->pixmap, parent->pm_gc, 2, segments); + copy_pixmaps: xcb_copy_area(conn, con->pixmap, con->frame, con->pm_gc, 0, 0, 0, 0, con->rect.width, con->rect.height); } @@ -561,7 +674,13 @@ void x_push_node(Con *con) { xcb_free_pixmap(conn, con->pixmap); xcb_free_gc(conn, con->pm_gc); } - xcb_create_pixmap(conn, root_depth, con->pixmap, con->frame, rect.width, rect.height); + + uint16_t win_depth = root_depth; + if (con->window) + win_depth = con->window->depth; + + xcb_create_pixmap(conn, win_depth, con->pixmap, con->frame, rect.width, rect.height); + /* For the graphics context, we disable GraphicsExposure events. * Those will be sent when a CopyArea request cannot be fulfilled * properly due to parts of the source being unmapped or otherwise @@ -693,7 +812,7 @@ static void x_push_node_unmaps(Con *con) { } cookie = xcb_unmap_window(conn, con->frame); - DLOG("unmapping container (serial %d)\n", cookie.sequence); + DLOG("unmapping container %p / %s (serial %d)\n", con, con->name, cookie.sequence); /* we need to increase ignore_unmap for this container (if it * contains a window) and for every window "under" this one which * contains a window */ @@ -824,26 +943,34 @@ void x_push_changes(Con *con) { /* Invalidate focused_id to correctly focus new windows with the same ID */ focused_id = XCB_NONE; } else { - DLOG("Updating focus (focused: %p / %s)\n", focused, focused->name); - /* We remove XCB_EVENT_MASK_FOCUS_CHANGE from the event mask to get - * no focus change events for our own focus changes. We only want - * these generated by the clients. */ - if (focused->window != NULL) { - values[0] = CHILD_EVENT_MASK & ~(XCB_EVENT_MASK_FOCUS_CHANGE); - xcb_change_window_attributes(conn, focused->window->id, XCB_CW_EVENT_MASK, values); - } - xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, to_focus, XCB_CURRENT_TIME); - if (focused->window != NULL) { - values[0] = CHILD_EVENT_MASK; - xcb_change_window_attributes(conn, focused->window->id, XCB_CW_EVENT_MASK, values); - } - + bool set_focus = true; if (focused->window != NULL && focused->window->needs_take_focus) { + DLOG("Updating focus by sending WM_TAKE_FOCUS to window 0x%08x (focused: %p / %s)\n", + to_focus, focused, focused->name); send_take_focus(to_focus); + set_focus = !focused->window->doesnt_accept_focus; + DLOG("set_focus = %d\n", set_focus); + } + + if (set_focus) { + DLOG("Updating focus (focused: %p / %s)\n", focused, focused->name); + /* We remove XCB_EVENT_MASK_FOCUS_CHANGE from the event mask to get + * no focus change events for our own focus changes. We only want + * these generated by the clients. */ + if (focused->window != NULL) { + values[0] = CHILD_EVENT_MASK & ~(XCB_EVENT_MASK_FOCUS_CHANGE); + xcb_change_window_attributes(conn, focused->window->id, XCB_CW_EVENT_MASK, values); + } + xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, to_focus, XCB_CURRENT_TIME); + if (focused->window != NULL) { + values[0] = CHILD_EVENT_MASK; + xcb_change_window_attributes(conn, focused->window->id, XCB_CW_EVENT_MASK, values); + } + + ewmh_update_active_window(to_focus); } - ewmh_update_active_window(to_focus); focused_id = to_focus; } } @@ -922,12 +1049,16 @@ void x_set_name(Con *con, const char *name) { * Sets up i3 specific atoms (I3_SOCKET_PATH and I3_CONFIG_PATH) * */ -void x_set_i3_atoms() { +void x_set_i3_atoms(void) { + pid_t pid = getpid(); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A_I3_SOCKET_PATH, A_UTF8_STRING, 8, (current_socketpath == NULL ? 0 : strlen(current_socketpath)), current_socketpath); + xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A_I3_PID, XCB_ATOM_CARDINAL, 32, 1, &pid); xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A_I3_CONFIG_PATH, A_UTF8_STRING, 8, strlen(current_configpath), current_configpath); + xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A_I3_SHMLOG_PATH, A_UTF8_STRING, 8, + strlen(shmlogname), shmlogname); } /* @@ -939,3 +1070,19 @@ void x_set_warp_to(Rect *rect) { warp_to = rect; } + +/* + * Applies the given mask to the event mask of every i3 window decoration X11 + * window. This is useful to disable EnterNotify while resizing so that focus + * is untouched. + * + */ +void x_mask_event_mask(uint32_t mask) { + uint32_t values[] = { FRAME_EVENT_MASK & mask }; + + con_state *state; + CIRCLEQ_FOREACH_REVERSE(state, &state_head, state) { + if (state->mapped) + xcb_change_window_attributes(conn, state->id, XCB_CW_EVENT_MASK, values); + } +}