Repository navigation
Expand file tree
/
Copy pathxwindow.c
More file actions
359 lines (318 loc) · 10.7 KB
/
Copy pathxwindow.c
File metadata and controls
359 lines (318 loc) · 10.7 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
/*
* xwindow.c - X window handling functions
*
* Copyright © 2007-2009 Julien Danjou <julien@danjou.info>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
#include <xcb/xcb.h>
#include <xcb/xcb_atom.h>
#include <xcb/shape.h>
#include <cairo-xcb.h>
#include "xwindow.h"
#include "objects/button.h"
#include "common/atoms.h"
/** Mask shorthands */
#define BUTTONMASK (XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE)
/** Set client state (WM_STATE) property.
* \param win The window to set state.
* \param state The state to set.
*/
void
xwindow_set_state(xcb_window_t win, uint32_t state)
{
uint32_t data[] = { state, XCB_NONE };
xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE, win,
WM_STATE, WM_STATE, 32, 2, data);
}
/** Send request to get a window state (WM_STATE).
* \param w A client window.
* \return The cookie associated with the request.
*/
xcb_get_property_cookie_t
xwindow_get_state_unchecked(xcb_window_t w)
{
return xcb_get_property_unchecked(globalconf.connection, false, w, WM_STATE,
WM_STATE, 0L, 2L);
}
/** Get a window state (WM_STATE).
* \param cookie The cookie.
* \return The current state of the window, or 0 on error.
*/
uint32_t
xwindow_get_state_reply(xcb_get_property_cookie_t cookie)
{
/* If no property is set, we just assume a sane default. */
uint32_t result = XCB_ICCCM_WM_STATE_NORMAL;
xcb_get_property_reply_t *prop_r;
if((prop_r = xcb_get_property_reply(globalconf.connection, cookie, NULL)))
{
if(xcb_get_property_value_length(prop_r))
result = *(uint32_t *) xcb_get_property_value(prop_r);
p_delete(&prop_r);
}
return result;
}
/** Configure a window with its new geometry and border size.
* \param win The X window id to configure.
* \param geometry The new window geometry.
* \param border The new border size.
*/
void
xwindow_configure(xcb_window_t win, area_t geometry, int border)
{
xcb_configure_notify_event_t ce;
ce.response_type = XCB_CONFIGURE_NOTIFY;
ce.event = win;
ce.window = win;
ce.x = geometry.x + border;
ce.y = geometry.y + border;
ce.width = geometry.width;
ce.height = geometry.height;
ce.border_width = border;
ce.above_sibling = XCB_NONE;
ce.override_redirect = false;
xcb_send_event(globalconf.connection, false, win, XCB_EVENT_MASK_STRUCTURE_NOTIFY, (char *) &ce);
}
/** Grab or ungrab buttons on a window.
* \param win The window.
* \param buttons The buttons to grab.
*/
void
xwindow_buttons_grab(xcb_window_t win, button_array_t *buttons)
{
if(win == XCB_NONE)
return;
/* Ungrab everything first */
xcb_ungrab_button(globalconf.connection, XCB_BUTTON_INDEX_ANY, win, XCB_BUTTON_MASK_ANY);
foreach(b, *buttons)
xcb_grab_button(globalconf.connection, false, win, BUTTONMASK,
XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, XCB_NONE, XCB_NONE,
(*b)->button, (*b)->modifiers);
}
/** Grab key on a window.
* \param win The window.
* \param k The key.
*/
static void
xwindow_grabkey(xcb_window_t win, keyb_t *k)
{
if(k->keycode)
xcb_grab_key(globalconf.connection, true, win,
k->modifiers, k->keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
else if(k->keysym)
{
xcb_keycode_t *keycodes = xcb_key_symbols_get_keycode(globalconf.keysyms, k->keysym);
if(keycodes)
{
for(xcb_keycode_t *kc = keycodes; *kc; kc++)
xcb_grab_key(globalconf.connection, true, win,
k->modifiers, *kc, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
p_delete(&keycodes);
}
}
}
void
xwindow_grabkeys(xcb_window_t win, key_array_t *keys)
{
/* Ungrab everything first */
xcb_ungrab_key(globalconf.connection, XCB_GRAB_ANY, win, XCB_BUTTON_MASK_ANY);
foreach(k, *keys)
xwindow_grabkey(win, *k);
}
/** Send a request for a window's opacity.
* \param win The window
* \return A cookie for xwindow_get_opacity_from_reply().
*/
xcb_get_property_cookie_t xwindow_get_opacity_unchecked(xcb_window_t win)
{
return xcb_get_property_unchecked(globalconf.connection, false, win,
_NET_WM_WINDOW_OPACITY, XCB_ATOM_CARDINAL, 0L, 1L);
}
/** Get the opacity of a window.
* \param win The window.
* \return The opacity, between 0 and 1 or -1 or no opacity set.
*/
double
xwindow_get_opacity(xcb_window_t win)
{
xcb_get_property_cookie_t prop_c =
xwindow_get_opacity_unchecked(win);
return xwindow_get_opacity_from_cookie(prop_c);
}
/** Get the opacity of a window.
* \param cookie A cookie for a reply to a get property request for _NET_WM_WINDOW_OPACITY.
* \return The opacity, between 0 and 1.
*/
double
xwindow_get_opacity_from_cookie(xcb_get_property_cookie_t cookie)
{
xcb_get_property_reply_t *prop_r =
xcb_get_property_reply(globalconf.connection, cookie, NULL);
if(prop_r && prop_r->value_len && prop_r->format == 32)
{
uint32_t value = *(uint32_t *) xcb_get_property_value(prop_r);
p_delete(&prop_r);
return (double) value / (double) 0xffffffff;
}
p_delete(&prop_r);
return -1;
}
/** Set opacity of a window.
* \param win The window.
* \param opacity Opacity of the window, between 0 and 1.
*/
void
xwindow_set_opacity(xcb_window_t win, double opacity)
{
if(win)
{
if(opacity >= 0 && opacity <= 1)
{
uint32_t real_opacity = opacity * 0xffffffff;
xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE, win,
_NET_WM_WINDOW_OPACITY, XCB_ATOM_CARDINAL, 32, 1L, &real_opacity);
}
else
xcb_delete_property(globalconf.connection, win, _NET_WM_WINDOW_OPACITY);
}
}
/** Send WM_TAKE_FOCUS client message to window
* \param win destination window
*/
void
xwindow_takefocus(xcb_window_t win)
{
xcb_client_message_event_t ev;
/* Initialize all of event's fields first */
p_clear(&ev, 1);
ev.response_type = XCB_CLIENT_MESSAGE;
ev.window = win;
ev.format = 32;
ev.data.data32[1] = globalconf.timestamp;
ev.type = WM_PROTOCOLS;
ev.data.data32[0] = WM_TAKE_FOCUS;
xcb_send_event(globalconf.connection, false, win,
XCB_EVENT_MASK_NO_EVENT, (char *) &ev);
}
/** Set window cursor.
* \param w The window.
* \param c The cursor.
*/
void
xwindow_set_cursor(xcb_window_t w, xcb_cursor_t c)
{
xcb_change_window_attributes(globalconf.connection, w, XCB_CW_CURSOR,
(const uint32_t[]) { c });
}
/** Set a window border color.
* \param w The window.
* \param color The color.
*/
void
xwindow_set_border_color(xcb_window_t w, color_t *color)
{
if(w)
xcb_change_window_attributes(globalconf.connection, w, XCB_CW_BORDER_PIXEL, &color->pixel);
}
/** Turn a cairo surface into a pixmap with depth 1 */
static xcb_pixmap_t
xwindow_shape_pixmap(int width, int height, cairo_surface_t *surf)
{
xcb_pixmap_t pixmap = xcb_generate_id(globalconf.connection);
cairo_surface_t *dest;
cairo_t *cr;
xcb_create_pixmap(globalconf.connection, 1, pixmap, globalconf.screen->root, width, height);
dest = cairo_xcb_surface_create_for_bitmap(globalconf.connection, globalconf.screen, pixmap, width, height);
cr = cairo_create(dest);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface(cr, surf, 0, 0);
cairo_paint(cr);
cairo_destroy(cr);
cairo_surface_flush(dest);
cairo_surface_finish(dest);
cairo_surface_destroy(dest);
return pixmap;
}
/** Set one of a window's shapes */
void
xwindow_set_shape(xcb_window_t win, int width, int height, enum xcb_shape_sk_t kind, cairo_surface_t *surf, int offset)
{
xcb_pixmap_t pixmap = XCB_NONE;
if (surf)
pixmap = xwindow_shape_pixmap(width, height, surf);
xcb_shape_mask(globalconf.connection, XCB_SHAPE_SO_SET, kind, win, offset, offset, pixmap);
if (pixmap != XCB_NONE)
xcb_free_pixmap(globalconf.connection, pixmap);
}
/** Calculate the position change that a window needs applied.
* \param gravity The window gravity that should be used.
* \param change_width_before The window width difference that will be applied.
* \param change_height_before The window height difference that will be applied.
* \param change_width_after The window width difference that will be applied.
* \param change_height_after The window height difference that will be applied.
* \param dx On return, this will be set to the amount the pixel has to be moved.
* \param dy On return, this will be set to the amount the pixel has to be moved.
*/
void xwindow_translate_for_gravity(xcb_gravity_t gravity, int16_t change_width_before, int16_t change_height_before,
int16_t change_width_after, int16_t change_height_after, int16_t *dx, int16_t *dy)
{
int16_t x = 0, y = 0;
int16_t change_height = change_height_before + change_height_after;
int16_t change_width = change_width_before + change_width_after;
switch (gravity) {
case XCB_GRAVITY_WIN_UNMAP:
case XCB_GRAVITY_NORTH_WEST:
break;
case XCB_GRAVITY_NORTH:
x = -change_width / 2;
break;
case XCB_GRAVITY_NORTH_EAST:
x = -change_width;
break;
case XCB_GRAVITY_WEST:
y = -change_height / 2;
break;
case XCB_GRAVITY_CENTER:
x = -change_width / 2;
y = -change_height / 2;
break;
case XCB_GRAVITY_EAST:
x = -change_width;
y = -change_height / 2;
break;
case XCB_GRAVITY_SOUTH_WEST:
y = -change_height;
break;
case XCB_GRAVITY_SOUTH:
x = -change_width / 2;
y = -change_height;
break;
case XCB_GRAVITY_SOUTH_EAST:
x = -change_width;
y = -change_height;
break;
case XCB_GRAVITY_STATIC:
x = -change_width_before;
x = -change_height_before;
break;
}
if (dx)
*dx = x;
if (dy)
*dy = y;
}
// vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80