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