git.sur5r.net Git - i3/i3/blob - src/xcb.c

   1 /*
   2  * vim:ts=4:sw=4:expandtab
   3  *
   4  * i3 - an improved dynamic tiling window manager
   5  * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
   6  *
   7  * xcb.c: Helper functions for easier usage of XCB
   8  *
   9  */
  10 #include "all.h"
  11
  12 unsigned int xcb_numlock_mask;
  13
  14 /*
  15  * Convenience wrapper around xcb_create_window which takes care of depth, generating an ID and checking
  16  * for errors.
  17  *
  18  */
  19 xcb_window_t create_window(xcb_connection_t *conn, Rect dims,
  20         uint16_t depth, xcb_visualid_t visual, uint16_t window_class,
  21         enum xcursor_cursor_t cursor, bool map, uint32_t mask, uint32_t *values) {
  22     xcb_window_t result = xcb_generate_id(conn);
  23
  24     /* If the window class is XCB_WINDOW_CLASS_INPUT_ONLY, we copy depth and
  25      * visual id from the parent window. */
  26     if (window_class == XCB_WINDOW_CLASS_INPUT_ONLY) {
  27         depth = XCB_COPY_FROM_PARENT;
  28         visual = XCB_COPY_FROM_PARENT;
  29     }
  30
  31     xcb_create_window(conn,
  32             depth,
  33             result, /* the window id */
  34             root, /* parent == root */
  35             dims.x, dims.y, dims.width, dims.height, /* dimensions */
  36             0, /* border = 0, we draw our own */
  37             window_class,
  38             visual,
  39             mask,
  40             values);
  41
  42     /* Set the cursor */
  43     if (xcursor_supported) {
  44         mask = XCB_CW_CURSOR;
  45         values[0] = xcursor_get_cursor(cursor);
  46         xcb_change_window_attributes(conn, result, mask, values);
  47     } else {
  48         xcb_cursor_t cursor_id = xcb_generate_id(conn);
  49         i3Font cursor_font = load_font("cursor", false);
  50         int xcb_cursor = xcursor_get_xcb_cursor(cursor);
  51         xcb_create_glyph_cursor(conn, cursor_id, cursor_font.id, cursor_font.id,
  52                 xcb_cursor, xcb_cursor + 1, 0, 0, 0, 65535, 65535, 65535);
  53         xcb_change_window_attributes(conn, result, XCB_CW_CURSOR, &cursor_id);
  54         xcb_free_cursor(conn, cursor_id);
  55     }
  56
  57     /* Map the window (= make it visible) */
  58     if (map)
  59         xcb_map_window(conn, result);
  60
  61     return result;
  62 }
  63
  64 /*
  65  * Draws a line from x,y to to_x,to_y using the given color
  66  *
  67  */
  68 void xcb_draw_line(xcb_connection_t *conn, xcb_drawable_t drawable, xcb_gcontext_t gc,
  69                    uint32_t colorpixel, uint32_t x, uint32_t y, uint32_t to_x, uint32_t to_y) {
  70     xcb_change_gc(conn, gc, XCB_GC_FOREGROUND, (uint32_t[]){ colorpixel });
  71     xcb_poly_line(conn, XCB_COORD_MODE_ORIGIN, drawable, gc, 2,
  72                   (xcb_point_t[]) { {x, y}, {to_x, to_y} });
  73 }
  74
  75 /*
  76  * Draws a rectangle from x,y with width,height using the given color
  77  *
  78  */
  79 void xcb_draw_rect(xcb_connection_t *conn, xcb_drawable_t drawable, xcb_gcontext_t gc,
  80                    uint32_t colorpixel, uint32_t x, uint32_t y, uint32_t width, uint32_t height) {
  81     xcb_change_gc(conn, gc, XCB_GC_FOREGROUND, (uint32_t[]){ colorpixel });
  82     xcb_rectangle_t rect = {x, y, width, height};
  83     xcb_poly_fill_rectangle(conn, drawable, gc, 1, &rect);
  84 }
  85
  86 /*
  87  * Generates a configure_notify_event with absolute coordinates (relative to the X root
  88  * window, not to the client’s frame) for the given client.
  89  *
  90  */
  91 void fake_absolute_configure_notify(Con *con) {
  92     xcb_rectangle_t absolute;
  93     if (con->window == NULL)
  94         return;
  95
  96     absolute.x = con->rect.x + con->window_rect.x;
  97     absolute.y = con->rect.y + con->window_rect.y;
  98     absolute.width = con->window_rect.width;
  99     absolute.height = con->window_rect.height;
 100
 101     DLOG("fake rect = (%d, %d, %d, %d)\n", absolute.x, absolute.y, absolute.width, absolute.height);
 102
 103     fake_configure_notify(conn, absolute, con->window->id, con->border_width);
 104 }
 105
 106 /*
 107  * Sends the WM_TAKE_FOCUS ClientMessage to the given window
 108  *
 109  */
 110 void send_take_focus(xcb_window_t window) {
 111     /* Every X11 event is 32 bytes long. Therefore, XCB will copy 32 bytes.
 112      * In order to properly initialize these bytes, we allocate 32 bytes even
 113      * though we only need less for an xcb_configure_notify_event_t */
 114     void *event = scalloc(32);
 115     xcb_client_message_event_t *ev = event;
 116
 117     ev->response_type = XCB_CLIENT_MESSAGE;
 118     ev->window = window;
 119     ev->type = A_WM_PROTOCOLS;
 120     ev->format = 32;
 121     ev->data.data32[0] = A_WM_TAKE_FOCUS;
 122     ev->data.data32[1] = XCB_CURRENT_TIME;
 123
 124     DLOG("Sending WM_TAKE_FOCUS to the client\n");
 125     xcb_send_event(conn, false, window, XCB_EVENT_MASK_NO_EVENT, (char*)ev);
 126     free(event);
 127 }
 128
 129 /*
 130  * Raises the given window (typically client->frame) above all other windows
 131  *
 132  */
 133 void xcb_raise_window(xcb_connection_t *conn, xcb_window_t window) {
 134     uint32_t values[] = { XCB_STACK_MODE_ABOVE };
 135     xcb_configure_window(conn, window, XCB_CONFIG_WINDOW_STACK_MODE, values);
 136 }
 137
 138 /*
 139  * Configures the given window to have the size/position specified by given rect
 140  *
 141  */
 142 void xcb_set_window_rect(xcb_connection_t *conn, xcb_window_t window, Rect r) {
 143     xcb_void_cookie_t cookie;
 144     cookie = xcb_configure_window(conn, window,
 145                          XCB_CONFIG_WINDOW_X |
 146                          XCB_CONFIG_WINDOW_Y |
 147                          XCB_CONFIG_WINDOW_WIDTH |
 148                          XCB_CONFIG_WINDOW_HEIGHT,
 149                          &(r.x));
 150     /* ignore events which are generated because we configured a window */
 151     add_ignore_event(cookie.sequence, -1);
 152 }
 153
 154 /*
 155  * Returns true if the given reply contains the given atom.
 156  *
 157  */
 158 bool xcb_reply_contains_atom(xcb_get_property_reply_t *prop, xcb_atom_t atom) {
 159     if (prop == NULL || xcb_get_property_value_length(prop) == 0)
 160         return false;
 161
 162     xcb_atom_t *atoms;
 163     if ((atoms = xcb_get_property_value(prop)) == NULL)
 164         return false;
 165
 166     for (int i = 0; i < xcb_get_property_value_length(prop) / (prop->format / 8); i++)
 167         if (atoms[i] == atom)
 168             return true;
 169
 170     return false;
 171
 172 }
 173
 174 /**
 175  * Moves the mouse pointer into the middle of rect.
 176  *
 177  */
 178 void xcb_warp_pointer_rect(xcb_connection_t *conn, Rect *rect) {
 179     int mid_x = rect->x + (rect->width / 2);
 180     int mid_y = rect->y + (rect->height / 2);
 181
 182     LOG("warp pointer to: %d %d\n", mid_x, mid_y);
 183     xcb_warp_pointer(conn, XCB_NONE, root, 0, 0, 0, 0, mid_x, mid_y);
 184 }
 185
 186 /*
 187  * Set the cursor of the root window to the given cursor id.
 188  * This function should only be used if xcursor_supported == false.
 189  * Otherwise, use xcursor_set_root_cursor().
 190  *
 191  */
 192 void xcb_set_root_cursor(int cursor) {
 193     xcb_cursor_t cursor_id = xcb_generate_id(conn);
 194     i3Font cursor_font = load_font("cursor", false);
 195     int xcb_cursor = xcursor_get_xcb_cursor(cursor);
 196     xcb_create_glyph_cursor(conn, cursor_id, cursor_font.id, cursor_font.id,
 197             xcb_cursor, xcb_cursor + 1, 0, 0, 0, 65535, 65535, 65535);
 198     xcb_change_window_attributes(conn, root, XCB_CW_CURSOR, &cursor_id);
 199     xcb_free_cursor(conn, cursor_id);
 200     xcb_flush(conn);
 201 }
 202
 203 /*
 204  * Get depth of visual specified by visualid
 205  *
 206  */
 207 uint16_t get_visual_depth(xcb_visualid_t visual_id){
 208     xcb_depth_iterator_t depth_iter;
 209
 210     depth_iter = xcb_screen_allowed_depths_iterator(root_screen);
 211     for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {
 212         xcb_visualtype_iterator_t visual_iter;
 213
 214         visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
 215         for (; visual_iter.rem; xcb_visualtype_next(&visual_iter)) {
 216             if (visual_id == visual_iter.data->visual_id) {
 217                 return depth_iter.data->depth;
 218             }
 219         }
 220     }
 221     return 0;
 222 }
 223
 224 /*
 225  * Get visualid with specified depth
 226  *
 227  */
 228 xcb_visualid_t get_visualid_by_depth(uint16_t depth){
 229     xcb_depth_iterator_t depth_iter;
 230
 231     depth_iter = xcb_screen_allowed_depths_iterator(root_screen);
 232     for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {
 233         if (depth_iter.data->depth != depth)
 234             continue;
 235
 236         xcb_visualtype_iterator_t visual_iter;
 237
 238         visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
 239         if (!visual_iter.rem)
 240             continue;
 241         return visual_iter.data->visual_id;
 242     }
 243     return 0;
 244 }