Use 32bit visual only when needed. Thus we could drop the --enable-32bit-visual option.

include/data.h

@@ -322,6 +322,9 @@ struct Window {
      * (assignments run only once) */
     uint32_t nr_assignments;
     Assignment **ran_assignments;
+
+    /** Depth of the window */
+    uint16_t depth;
 };
 
 /**

include/x.h

@@ -19,7 +19,7 @@ extern xcb_window_t focused_id;
  * every container from con_new().
  *
  */
-void x_con_init(Con *con);
+void x_con_init(Con *con, uint16_t depth);
 
 /**
  * Moves a child window from Container src to Container dest.

include/xcb.h

@@ -56,8 +56,8 @@ extern unsigned int xcb_numlock_mask;
  * generating an ID and checking for errors.
  *
  */
-xcb_window_t create_window(xcb_connection_t *conn, Rect r, uint16_t window_class,
+xcb_window_t create_window(xcb_connection_t *conn, Rect r, uint16_t depth, xcb_visualid_t visual,
-        enum xcursor_cursor_t cursor, bool map, uint32_t mask, uint32_t *values);
+        uint16_t window_class, enum xcursor_cursor_t cursor, bool map, uint32_t mask, uint32_t *values);
 
 /**
  * Draws a line from x,y to to_x,to_y using the given color
@@ -117,4 +117,8 @@ void xcb_warp_pointer_rect(xcb_connection_t *conn, Rect *rect);
  */
 void xcb_set_root_cursor(int cursor);
 
+uint16_t get_visual_depth(xcb_visualid_t visual_id);
+
+xcb_visualid_t get_visualid_by_depth(uint16_t depth);
+
 #endif

src/con.c

@@ -49,8 +49,10 @@ Con *con_new(Con *parent, i3Window *window) {
     cnt++;
     if ((cnt % (sizeof(colors) / sizeof(char*))) == 0)
         cnt = 0;
-
+    if (window)
-    x_con_init(new);
+        x_con_init(new, window->depth);
+    else
+        x_con_init(new, XCB_COPY_FROM_PARENT);
 
     TAILQ_INIT(&(new->floating_head));
     TAILQ_INIT(&(new->nodes_head));

src/main.c

@@ -253,7 +253,6 @@ int main(int argc, char *argv[]) {
     bool delete_layout_path = false;
     bool force_xinerama = false;
     bool disable_signalhandler = false;
-    bool enable_32bit_visual = false;
     static struct option long_options[] = {
         {"no-autostart", no_argument, 0, 'a'},
         {"config", required_argument, 0, 'c'},
@@ -268,8 +267,6 @@ int main(int argc, char *argv[]) {
         {"shmlog_size", required_argument, 0, 0},
         {"get-socketpath", no_argument, 0, 0},
         {"get_socketpath", no_argument, 0, 0},
-        {"enable-32bit-visual", no_argument, 0, 0},
-        {"enable_32bit_visual", no_argument, 0, 0},
         {0, 0, 0, 0}
     };
     int option_index = 0, opt;
@@ -371,11 +368,6 @@ int main(int argc, char *argv[]) {
                     layout_path = sstrdup(optarg);
                     delete_layout_path = true;
                     break;
-                } else if (strcmp(long_options[option_index].name, "enable_32bit_visual") == 0 ||
-                           strcmp(long_options[option_index].name, "enable-32bit-visual") == 0) {
-                    LOG("Enabling 32 bit visual (if available)\n");
-                    enable_32bit_visual = true;
-                    break;
                 }
                 /* fall-through */
             default:
@@ -402,10 +394,6 @@ int main(int argc, char *argv[]) {
                                 "\tto 0 disables SHM logging entirely.\n"
                                 "\tThe default is %d bytes.\n", shmlog_size);
                 fprintf(stderr, "\n");
-                fprintf(stderr, "\t--enable-32bit-visual\n"
-                                "\tMakes i3 use a 32 bit visual, if available. Necessary for\n"
-                                "\tpseudo-transparency with xcompmgr.\n");
-                fprintf(stderr, "\n");
                 fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
                                 "to send to a currently running i3 (like i3-msg). This allows you to\n"
                                 "use nice and logical commands, such as:\n"
@@ -525,27 +513,6 @@ int main(int argc, char *argv[]) {
     visual_id = root_screen->root_visual;
     colormap = root_screen->default_colormap;
 
-    if (enable_32bit_visual) {
-        xcb_depth_iterator_t depth_iter;
-        xcb_visualtype_iterator_t visual_iter;
-        for (depth_iter = xcb_screen_allowed_depths_iterator(root_screen);
-             depth_iter.rem;
-             xcb_depth_next(&depth_iter)) {
-            if (depth_iter.data->depth != 32)
-                continue;
-            visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
-            if (!visual_iter.rem)
-                continue;
-
-            visual_id = visual_iter.data->visual_id;
-            root_depth = depth_iter.data->depth;
-            colormap = xcb_generate_id(conn);
-            colormap_cookie = xcb_create_colormap_checked(conn, XCB_COLORMAP_ALLOC_NONE, colormap, root, visual_id);
-            DLOG("Found a visual with 32 bit depth.\n");
-            break;
-        }
-    }
-
     DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_id);
 
     xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);

src/manage.c

@@ -149,6 +149,7 @@ void manage_window(xcb_window_t window, xcb_get_window_attributes_cookie_t cooki
 
     i3Window *cwindow = scalloc(sizeof(i3Window));
     cwindow->id = window;
+    cwindow->depth = get_visual_depth(attr->visual);
 
     /* We need to grab the mouse buttons for click to focus */
     xcb_grab_button(conn, false, window, XCB_EVENT_MASK_BUTTON_PRESS,

src/resize.c

@@ -69,7 +69,8 @@ int resize_graphical_handler(Con *first, Con *second, orientation_t orientation,
 
     /* Open a new window, the resizebar. Grab the pointer and move the window around
        as the user moves the pointer. */
-    xcb_window_t grabwin = create_window(conn, output->rect, XCB_WINDOW_CLASS_INPUT_ONLY, XCURSOR_CURSOR_POINTER, true, mask, values);
+    xcb_window_t grabwin = create_window(conn, output->rect, XCB_COPY_FROM_PARENT, XCB_COPY_FROM_PARENT,
+            XCB_WINDOW_CLASS_INPUT_ONLY, XCURSOR_CURSOR_POINTER, true, mask, values);
 
     Rect helprect;
     if (orientation == HORIZ) {
@@ -92,8 +93,8 @@ int resize_graphical_handler(Con *first, Con *second, orientation_t orientation,
     mask |= XCB_CW_OVERRIDE_REDIRECT;
     values[1] = 1;
 
-    xcb_window_t helpwin = create_window(conn, helprect, XCB_WINDOW_CLASS_INPUT_OUTPUT,
+    xcb_window_t helpwin = create_window(conn, helprect, XCB_COPY_FROM_PARENT, XCB_COPY_FROM_PARENT,
-                                         (orientation == HORIZ ?
+            XCB_WINDOW_CLASS_INPUT_OUTPUT, (orientation == HORIZ ?
                                           XCURSOR_CURSOR_RESIZE_HORIZONTAL :
                                           XCURSOR_CURSOR_RESIZE_VERTICAL), true, mask, values);
 

src/x.c

@@ -85,7 +85,7 @@ 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 */
 
@@ -96,6 +96,12 @@ void x_con_init(Con *con) {
      * 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 */
+    xcb_visualid_t visual = XCB_COPY_FROM_PARENT;
+    if (depth != root_depth && depth != XCB_COPY_FROM_PARENT) {
+        visual = get_visualid_by_depth(depth);
+        xcb_colormap_t win_colormap = xcb_generate_id(conn);
+        xcb_create_colormap_checked(conn, XCB_COLORMAP_ALLOC_NONE, win_colormap, root, visual);
+
         mask |= XCB_CW_BACK_PIXEL;
         values[0] = root_screen->black_pixel;
 
@@ -111,10 +117,23 @@ void x_con_init(Con *con) {
         values[3] = FRAME_EVENT_MASK & ~XCB_EVENT_MASK_ENTER_WINDOW;
 
         mask |= XCB_CW_COLORMAP;
-    values[4] = colormap;
+        values[4] = win_colormap;
+    } else {
+        mask = XCB_CW_OVERRIDE_REDIRECT;
+        values[0] = 1;
+
+        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 (depth != root_depth && depth != XCB_COPY_FROM_PARENT)
+        xcb_free_colormap(conn, values[4]);
 
     struct con_state *state = scalloc(sizeof(struct con_state));
     state->id = con->frame;
@@ -614,7 +633,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

src/xcb.c

@@ -16,15 +16,11 @@ unsigned int xcb_numlock_mask;
  * for errors.
  *
  */
-xcb_window_t create_window(xcb_connection_t *conn, Rect dims, uint16_t window_class,
+xcb_window_t create_window(xcb_connection_t *conn, Rect dims,
+        uint16_t depth, xcb_visualid_t visual, uint16_t window_class,
         enum xcursor_cursor_t cursor, bool map, uint32_t mask, uint32_t *values) {
     xcb_window_t result = xcb_generate_id(conn);
 
-    /* By default, the color depth determined in src/main.c is used (32 bit if
-     * available, otherwise the X11 root window’s default depth). */
-    uint16_t depth = root_depth;
-    xcb_visualid_t visual = visual_id;
-
     /* If the window class is XCB_WINDOW_CLASS_INPUT_ONLY, we copy depth and
      * visual id from the parent window. */
     if (window_class == XCB_WINDOW_CLASS_INPUT_ONLY) {
@@ -203,3 +199,46 @@ void xcb_set_root_cursor(int cursor) {
     xcb_free_cursor(conn, cursor_id);
     xcb_flush(conn);
 }
+
+/*
+ * Get depth of visual specified by visualid
+ *
+ */
+uint16_t get_visual_depth(xcb_visualid_t visual_id){
+    xcb_depth_iterator_t depth_iter;
+
+    depth_iter = xcb_screen_allowed_depths_iterator(root_screen);
+    for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {
+        xcb_visualtype_iterator_t visual_iter;
+
+        visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
+        for (; visual_iter.rem; xcb_visualtype_next(&visual_iter)) {
+            if (visual_id == visual_iter.data->visual_id) {
+                return depth_iter.data->depth;
+            }
+        }
+    }
+    return 0;
+}
+
+/*
+ * Get visualid with specified depth
+ *
+ */
+xcb_visualid_t get_visualid_by_depth(uint16_t depth){
+    xcb_depth_iterator_t depth_iter;
+
+    depth_iter = xcb_screen_allowed_depths_iterator(root_screen);
+    for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {
+        if (depth_iter.data->depth != depth)
+            continue;
+
+        xcb_visualtype_iterator_t visual_iter;
+
+        visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
+        if (!visual_iter.rem)
+            continue;
+        return visual_iter.data->visual_id;
+    }
+    return 0;
+}