X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fx.c;h=6c5a11ecaf9cd22fd7e73284fa8d21c769a1f19d;hb=6f8b2845863e9071d7d630b270729d46423c1eb5;hp=5136bf445d6a156628e068861a38c3fec62ec0d7;hpb=52b3646ecc5a2d3399ddf52476c124b8cae588b2;p=i3%2Fi3

diff --git a/src/x.c b/src/x.c
index 5136bf44..6c5a11ec 100644
--- a/src/x.c
+++ b/src/x.c
@@ -1,12 +1,26 @@
 /*
  * vim:ts=4:sw=4:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ * © 2009-2011 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.
+ *
  */
-
 #include "all.h"
 
 /* Stores the X11 window ID of the currently focused window */
 xcb_window_t focused_id = XCB_NONE;
 
+/* The bottom-to-top window stack of all windows which are managed by i3.
+ * Used for x_get_window_stack(). */
+static xcb_window_t *btt_stack;
+static int btt_stack_num;
+
+/* Stores coordinates to warp mouse pointer to if set */
+static Rect *warp_to;
+
 /*
  * Describes the X11 state we may modify (map state, position, window stack).
  * There is one entry per container. The state represents the current situation
@@ -21,6 +35,9 @@ typedef struct con_state {
     bool unmap_now;
     bool child_mapped;
 
+    /** The con for which this state is. */
+    Con *con;
+
     /* For reparenting, we have a flag (need_reparent) and the X ID of the old
      * frame this window was in. The latter is necessary because we need to
      * ignore UnmapNotify events (by changing the window event mask). */
@@ -112,6 +129,7 @@ void x_reinit(Con *con) {
     DLOG("resetting state %p to initial\n", state);
     state->initial = true;
     state->child_mapped = false;
+    state->con = con;
     memset(&(state->window_rect), 0, sizeof(Rect));
 }
 
@@ -148,6 +166,9 @@ void x_move_win(Con *src, Con *dest) {
         return;
     }
 
+    state_dest->con = state_src->con;
+    state_src->con = NULL;
+
     Rect zero = { 0, 0, 0, 0 };
     if (memcmp(&(state_dest->window_rect), &(zero), sizeof(Rect)) == 0) {
         memcpy(&(state_dest->window_rect), &(state_src->window_rect), sizeof(Rect));
@@ -215,20 +236,23 @@ void x_window_kill(xcb_window_t window, kill_window_t kill_window) {
         return;
     }
 
-    xcb_client_message_event_t ev;
-
-    memset(&ev, 0, sizeof(xcb_client_message_event_t));
+    /* Every X11 event is 32 bytes long. Therefore, XCB will copy 32 bytes.
+     * In order to properly initialize these bytes, we allocate 32 bytes even
+     * though we only need less for an xcb_configure_notify_event_t */
+    void *event = scalloc(32);
+    xcb_client_message_event_t *ev = event;
 
-    ev.response_type = XCB_CLIENT_MESSAGE;
-    ev.window = window;
-    ev.type = A_WM_PROTOCOLS;
-    ev.format = 32;
-    ev.data.data32[0] = A_WM_DELETE_WINDOW;
-    ev.data.data32[1] = XCB_CURRENT_TIME;
+    ev->response_type = XCB_CLIENT_MESSAGE;
+    ev->window = window;
+    ev->type = A_WM_PROTOCOLS;
+    ev->format = 32;
+    ev->data.data32[0] = A_WM_DELETE_WINDOW;
+    ev->data.data32[1] = XCB_CURRENT_TIME;
 
     LOG("Sending WM_DELETE to the client\n");
-    xcb_send_event(conn, false, window, XCB_EVENT_MASK_NO_EVENT, (char*)&ev);
+    xcb_send_event(conn, false, window, XCB_EVENT_MASK_NO_EVENT, (char*)ev);
     xcb_flush(conn);
+    free(event);
 }
 
 /*
@@ -237,6 +261,7 @@ 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
@@ -244,26 +269,21 @@ void x_draw_decoration(Con *con) {
      * It does not need to run for:
      *  • floating containers (they don’t have a decoration)
      */
-    if ((!con_is_leaf(con) &&
+    if ((!leaf &&
          parent->layout != L_STACKED &&
          parent->layout != L_TABBED) ||
         con->type == CT_FLOATING_CON)
         return;
-    DLOG("decoration should be rendered for con %p\n", con);
 
     /* Skip containers whose height is 0 (for example empty dockareas) */
-    if (con->rect.height == 0) {
-        DLOG("height == 0, not rendering\n");
+    if (con->rect.height == 0)
         return;
-    }
 
     /* Skip containers whose pixmap has not yet been created (can happen when
      * decoration rendering happens recursively for a window for which
      * x_push_node() was not yet called) */
-    if (con->pixmap == XCB_NONE) {
-        DLOG("pixmap not yet created, not rendering\n");
+    if (leaf && con->pixmap == XCB_NONE)
         return;
-    }
 
     /* 1: build deco_params and compare with cache */
     struct deco_render_params *p = scalloc(sizeof(struct deco_render_params));
@@ -271,7 +291,7 @@ void x_draw_decoration(Con *con) {
     /* find out which colors to use */
     if (con->urgent)
         p->color = &config.client.urgent;
-    else if (con == focused)
+    else if (con == focused || con_inside_focused(con))
         p->color = &config.client.focused;
     else if (con == TAILQ_FIRST(&(parent->focus_head)))
         p->color = &config.client.focused_inactive;
@@ -287,22 +307,18 @@ 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->font = config.font.id;
 
     if (con->deco_render_params != NULL &&
         (con->window == NULL || !con->window->name_x_changed) &&
         !parent->pixmap_recreated &&
         !con->pixmap_recreated &&
         memcmp(p, con->deco_render_params, sizeof(struct deco_render_params)) == 0) {
-        DLOG("CACHE HIT, copying existing pixmaps\n");
         free(p);
         goto copy_pixmaps;
     }
 
-    DLOG("CACHE MISS\n");
     Con *next = con;
     while ((next = TAILQ_NEXT(next, nodes))) {
-        DLOG("Also invalidating cache of %p\n", next);
         FREE(next->deco_render_params);
     }
 
@@ -337,7 +353,7 @@ void x_draw_decoration(Con *con) {
                 );
 #endif
 
-        xcb_change_gc_single(conn, con->pm_gc, XCB_GC_FOREGROUND, config.client.background);
+        xcb_change_gc(conn, con->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]) { config.client.background });
         xcb_poly_fill_rectangle(conn, con->pixmap, con->pm_gc, sizeof(background) / sizeof(xcb_rectangle_t), background);
     }
 
@@ -354,7 +370,7 @@ void x_draw_decoration(Con *con) {
          * (left, bottom and right part). We don’t just fill the whole
          * rectangle because some childs are not freely resizable and we want
          * their background color to "shine through". */
-        xcb_change_gc_single(conn, con->pm_gc, XCB_GC_FOREGROUND, p->color->background);
+        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 },
@@ -370,48 +386,38 @@ void x_draw_decoration(Con *con) {
 
     /* if this is a borderless/1pixel window, we don’t * need to render the
      * decoration. */
-    if (p->border_style != BS_NORMAL) {
-        DLOG("border style not BS_NORMAL, aborting rendering of decoration\n");
+    if (p->border_style != BS_NORMAL)
         goto copy_pixmaps;
-    }
 
     /* 4: paint the bar */
-    xcb_change_gc_single(conn, parent->pm_gc, XCB_GC_FOREGROUND, p->color->background);
+    xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]){ p->color->background });
     xcb_rectangle_t drect = { con->deco_rect.x, con->deco_rect.y, con->deco_rect.width, con->deco_rect.height };
     xcb_poly_fill_rectangle(conn, parent->pixmap, parent->pm_gc, 1, &drect);
 
     /* 5: draw two unconnected lines in border color */
-    xcb_change_gc_single(conn, parent->pm_gc, XCB_GC_FOREGROUND, p->color->border);
+    xcb_change_gc(conn, parent->pm_gc, XCB_GC_FOREGROUND, (uint32_t[]){ p->color->border });
     Rect *dr = &(con->deco_rect);
     xcb_segment_t segments[] = {
-        { dr->x,             dr->y,
-          dr->x + dr->width, dr->y },
+        { dr->x,                 dr->y,
+          dr->x + dr->width - 1, dr->y },
 
-        { dr->x,             dr->y + dr->height - 1,
-          dr->x + dr->width, dr->y + dr->height - 1 }
+        { dr->x + 2,             dr->y + dr->height - 1,
+          dr->x + dr->width - 3, dr->y + dr->height - 1 }
     };
     xcb_poly_segment(conn, parent->pixmap, parent->pm_gc, 2, segments);
 
     /* 6: draw the title */
-    uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
-    uint32_t values[] = { p->color->text, p->color->background, config.font.id };
-    xcb_change_gc(conn, parent->pm_gc, mask, values);
-    int text_offset_y = config.font.height + (con->deco_rect.height - config.font.height) / 2 - 1;
+    set_font_colors(parent->pm_gc, p->color->text, p->color->background);
+    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"
-        xcb_image_text_8(
-            conn,
-            strlen("another container"),
-            parent->pixmap,
-            parent->pm_gc,
-            con->deco_rect.x + 2,
-            con->deco_rect.y + text_offset_y,
-            "another container"
-        );
-
+        draw_text("another container", strlen("another container"), false,
+                parent->pixmap, parent->pm_gc,
+                con->deco_rect.x + 2, con->deco_rect.y + text_offset_y,
+                con->deco_rect.width - 2);
         goto copy_pixmaps;
     }
 
@@ -420,7 +426,7 @@ void x_draw_decoration(Con *con) {
     Con *il_parent = parent;
     if (il_parent->layout != L_STACKED) {
         while (1) {
-            DLOG("il_parent = %p, layout = %d\n", il_parent, il_parent->layout);
+            //DLOG("il_parent = %p, layout = %d\n", il_parent, il_parent->layout);
             if (il_parent->layout == L_STACKED)
                 indent_level++;
             if (il_parent->type == CT_WORKSPACE || il_parent->type == CT_DOCKAREA || il_parent->type == CT_OUTPUT)
@@ -429,29 +435,13 @@ void x_draw_decoration(Con *con) {
             indent_mult++;
         }
     }
-    DLOG("indent_level = %d, indent_mult = %d\n", indent_level, indent_mult);
+    //DLOG("indent_level = %d, indent_mult = %d\n", indent_level, indent_mult);
     int indent_px = (indent_level * 5) * indent_mult;
 
-    if (win->uses_net_wm_name)
-        xcb_image_text_16(
-            conn,
-            win->name_len,
-            parent->pixmap,
-            parent->pm_gc,
-            con->deco_rect.x + 2 + indent_px,
-            con->deco_rect.y + text_offset_y,
-            (xcb_char2b_t*)win->name_x
-        );
-    else
-        xcb_image_text_8(
-            conn,
-            win->name_len,
-            parent->pixmap,
-            parent->pm_gc,
-            con->deco_rect.x + 2 + indent_px,
-            con->deco_rect.y + text_offset_y,
-            win->name_x
-        );
+    draw_text(win->name_x, win->name_len, win->uses_net_wm_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);
 
 copy_pixmaps:
     xcb_copy_area(conn, con->pixmap, con->frame, con->pm_gc, 0, 0, 0, 0, con->rect.width, con->rect.height);
@@ -481,7 +471,7 @@ void x_deco_recurse(Con *con) {
     }
 
     if ((con->type != CT_ROOT && con->type != CT_OUTPUT) &&
-        con->mapped)
+        (!leaf || con->mapped))
         x_draw_decoration(con);
 }
 
@@ -503,7 +493,7 @@ void x_push_node(Con *con) {
         DLOG("pushing name %s for con %p\n", state->name, con);
 
         xcb_change_property(conn, XCB_PROP_MODE_REPLACE, con->frame,
-                            A_WM_NAME, A_STRING, 8, strlen(state->name), state->name);
+                            XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8, strlen(state->name), state->name);
         FREE(state->name);
     }
 
@@ -519,10 +509,8 @@ void x_push_node(Con *con) {
             }
         }
         rect.height = max_y + max_height;
-        if (rect.height == 0) {
-            DLOG("Unmapping container %p because it does not contain anything.\n", con);
+        if (rect.height == 0)
             con->mapped = false;
-        }
     }
 
     /* reparent the child window (when the window was moved due to a sticky
@@ -566,9 +554,6 @@ void x_push_node(Con *con) {
          * (height == 0). */
         if ((state->rect.width != rect.width ||
             state->rect.height != rect.height)) {
-            DLOG("CACHE: creating new pixmap for con %p (old: %d x %d, new: %d x %d)\n",
-                    con, state->rect.width, state->rect.height,
-                    rect.width, rect.height);
             if (con->pixmap == 0) {
                 con->pixmap = xcb_generate_id(conn);
                 con->pm_gc = xcb_generate_id(conn);
@@ -740,6 +725,12 @@ static void x_push_node_unmaps(Con *con) {
  */
 void x_push_changes(Con *con) {
     con_state *state;
+    xcb_query_pointer_cookie_t pointercookie;
+
+    /* If we need to warp later, we request the pointer position as soon as possible */
+    if (warp_to) {
+        pointercookie = xcb_query_pointer(conn, root);
+    }
 
     DLOG("-- PUSHING WINDOW STACK --\n");
     //DLOG("Disabling EnterNotify\n");
@@ -750,15 +741,35 @@ void x_push_changes(Con *con) {
     }
     //DLOG("Done, EnterNotify disabled\n");
     bool order_changed = false;
+    bool stacking_changed = false;
+
+    /* count first, necessary to (re)allocate memory for the bottom-to-top
+     * stack afterwards */
+    int cnt = 0;
+    CIRCLEQ_FOREACH_REVERSE(state, &state_head, state)
+        if (state->con && state->con->window)
+            cnt++;
+
+    if (cnt != btt_stack_num) {
+        btt_stack = srealloc(btt_stack, sizeof(xcb_window_t) * cnt);
+        btt_stack_num = cnt;
+    }
+
+    xcb_window_t *walk = btt_stack;
+
     /* X11 correctly represents the stack if we push it from bottom to top */
     CIRCLEQ_FOREACH_REVERSE(state, &state_head, state) {
+        if (state->con && state->con->window)
+            memcpy(walk++, &(state->con->window->id), sizeof(xcb_window_t));
+
         //DLOG("stack: 0x%08x\n", state->id);
         con_state *prev = CIRCLEQ_PREV(state, state);
         con_state *old_prev = CIRCLEQ_PREV(state, old_state);
         if (prev != old_prev)
             order_changed = true;
         if ((state->initial || order_changed) && prev != CIRCLEQ_END(&state_head)) {
-            DLOG("Stacking 0x%08x above 0x%08x\n", prev->id, state->id);
+            stacking_changed = true;
+            //DLOG("Stacking 0x%08x above 0x%08x\n", prev->id, state->id);
             uint32_t mask = 0;
             mask |= XCB_CONFIG_WINDOW_SIBLING;
             mask |= XCB_CONFIG_WINDOW_STACK_MODE;
@@ -768,6 +779,31 @@ void x_push_changes(Con *con) {
         }
         state->initial = false;
     }
+
+    /* If we re-stacked something (or a new window appeared), we need to update
+     * the _NET_CLIENT_LIST_STACKING hint */
+    if (stacking_changed)
+        ewmh_update_client_list_stacking(btt_stack, btt_stack_num);
+
+    DLOG("PUSHING CHANGES\n");
+    x_push_node(con);
+
+    if (warp_to) {
+        xcb_query_pointer_reply_t *pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL);
+        if (!pointerreply) {
+            ELOG("Could not query pointer position, not warping pointer\n");
+        } else {
+            int mid_x = warp_to->x + (warp_to->width / 2);
+            int mid_y = warp_to->y + (warp_to->height / 2);
+
+            Output *current = get_output_containing(pointerreply->root_x, pointerreply->root_y);
+            Output *target = get_output_containing(mid_x, mid_y);
+            if (current != target)
+                xcb_warp_pointer(conn, XCB_NONE, root, 0, 0, 0, 0, mid_x, mid_y);
+        }
+        warp_to = NULL;
+    }
+
     //DLOG("Re-enabling EnterNotify\n");
     values[0] = FRAME_EVENT_MASK;
     CIRCLEQ_FOREACH_REVERSE(state, &state_head, state) {
@@ -776,15 +812,12 @@ void x_push_changes(Con *con) {
     }
     //DLOG("Done, EnterNotify re-enabled\n");
 
-    DLOG("\n\n PUSHING CHANGES\n\n");
-    x_push_node(con);
     x_deco_recurse(con);
 
     xcb_window_t to_focus = focused->frame;
     if (focused->window != NULL)
         to_focus = focused->window->id;
 
-    DLOG("focused_id = 0x%08x, to_focus = 0x%08x\n", focused_id, to_focus);
     if (focused_id != to_focus) {
         if (!focused->mapped) {
             DLOG("Not updating focus (to %p / %s), focused window is not mapped.\n", focused, focused->name);
@@ -822,7 +855,7 @@ void x_push_changes(Con *con) {
     }
 
     xcb_flush(conn);
-    DLOG("\n\n ENDING CHANGES\n\n");
+    DLOG("ENDING CHANGES\n");
 
     /* Disable EnterWindow events for windows which will be unmapped in
      * x_push_node_unmaps() now. Unmapping windows happens when switching
@@ -896,3 +929,29 @@ void x_set_i3_atoms() {
     xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A_I3_CONFIG_PATH, A_UTF8_STRING, 8,
                         strlen(current_configpath), current_configpath);
 }
+
+/*
+ * Set warp_to coordinates.  This will trigger on the next call to
+ * x_push_changes().
+ *
+ */
+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);
+    }
+}