i3
match.c
Go to the documentation of this file.
1/*
2 * vim:ts=4:sw=4:expandtab
3 *
4 * i3 - an improved tiling window manager
5 * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
6 *
7 * A "match" is a data structure which acts like a mask or expression to match
8 * certain windows or not. For example, when using commands, you can specify a
9 * command like this: [title="*Firefox*"] kill. The title member of the match
10 * data structure will then be filled and i3 will check each window using
11 * match_matches_window() to find the windows affected by this command.
12 *
13 */
14#include "all.h"
15
16/* From sys/time.h, not sure if it’s available on all systems. */
17#define _i3_timercmp(a, b, CMP) \
18 (((a).tv_sec == (b).tv_sec) ? ((a).tv_usec CMP(b).tv_usec) : ((a).tv_sec CMP(b).tv_sec))
19
20/*
21 * Initializes the Match data structure. This function is necessary because the
22 * members representing boolean values (like dock) need to be initialized with
23 * -1 instead of 0.
24 *
25 */
26void match_init(Match *match) {
27 memset(match, 0, sizeof(Match));
28 match->urgent = U_DONTCHECK;
29 match->window_mode = WM_ANY;
30 /* we use this as the placeholder value for "not set". */
31 match->window_type = UINT32_MAX;
32}
33
34/*
35 * Check if a match is empty. This is necessary while parsing commands to see
36 * whether the user specified a match at all.
37 *
38 */
39bool match_is_empty(Match *match) {
40 /* we cannot simply use memcmp() because the structure is part of a
41 * TAILQ and I don’t want to start with things like assuming that the
42 * last member of a struct really is at the end in memory… */
43 return (match->title == NULL &&
44 match->mark == NULL &&
45 match->application == NULL &&
46 match->class == NULL &&
47 match->instance == NULL &&
48 match->window_role == NULL &&
49 match->workspace == NULL &&
50 match->machine == NULL &&
51 match->urgent == U_DONTCHECK &&
52 match->id == XCB_NONE &&
53 match->window_type == UINT32_MAX &&
54 match->con_id == NULL &&
55 match->dock == M_NODOCK &&
56 match->window_mode == WM_ANY &&
57 match->match_all_windows == false);
58}
59
60/*
61 * Copies the data of a match from src to dest.
62 *
63 */
64void match_copy(Match *dest, Match *src) {
65 memcpy(dest, src, sizeof(Match));
66
67/* The DUPLICATE_REGEX macro creates a new regular expression from the
68 * ->pattern of the old one. It therefore does use a little more memory then
69 * with a refcounting system, but it’s easier this way. */
70#define DUPLICATE_REGEX(field) \
71 do { \
72 if (src->field != NULL) \
73 dest->field = regex_new(src->field->pattern); \
74 } while (0)
75
76 DUPLICATE_REGEX(title);
77 DUPLICATE_REGEX(mark);
78 DUPLICATE_REGEX(application);
79 DUPLICATE_REGEX(class);
80 DUPLICATE_REGEX(instance);
81 DUPLICATE_REGEX(window_role);
82 DUPLICATE_REGEX(workspace);
83 DUPLICATE_REGEX(machine);
84}
85
86/*
87 * Check if a match data structure matches the given window.
88 *
89 */
90bool match_matches_window(Match *match, i3Window *window) {
91 LOG("Checking window 0x%08x (class %s)\n", window->id, window->class_class);
92
93#define GET_FIELD_str(field) (field)
94#define GET_FIELD_i3string(field) (i3string_as_utf8(field))
95#define CHECK_WINDOW_FIELD(match_field, window_field, type) \
96 do { \
97 if (match->match_field != NULL) { \
98 const char *window_field_str = window->window_field == NULL \
99 ? "" \
100 : GET_FIELD_##type(window->window_field); \
101 if (strcmp(match->match_field->pattern, "__focused__") == 0 && \
102 focused && focused->window && focused->window->window_field && \
103 strcmp(window_field_str, GET_FIELD_##type(focused->window->window_field)) == 0) { \
104 LOG("window " #match_field " matches focused window\n"); \
105 } else if (regex_matches(match->match_field, window_field_str)) { \
106 LOG("window " #match_field " matches (%s)\n", window_field_str); \
107 } else { \
108 return false; \
109 } \
110 } \
111 } while (0)
112
113 CHECK_WINDOW_FIELD(class, class_class, str);
114 CHECK_WINDOW_FIELD(instance, class_instance, str);
115
116 if (match->id != XCB_NONE) {
117 if (window->id == match->id) {
118 LOG("match made by window id (%d)\n", window->id);
119 } else {
120 LOG("window id does not match\n");
121 return false;
122 }
123 }
124
125 CHECK_WINDOW_FIELD(title, name, i3string);
126 CHECK_WINDOW_FIELD(window_role, role, str);
127
128 if (match->window_type != UINT32_MAX) {
129 if (window->window_type == match->window_type) {
130 LOG("window_type matches (%i)\n", match->window_type);
131 } else {
132 return false;
133 }
134 }
135
136 CHECK_WINDOW_FIELD(machine, machine, str);
137
138 Con *con = NULL;
139 if (match->urgent == U_LATEST) {
140 /* if the window isn't urgent, no sense in searching */
141 if (window->urgent.tv_sec == 0) {
142 return false;
143 }
144 /* if we find a window that is newer than this one, bail */
146 if ((con->window != NULL) &&
147 _i3_timercmp(con->window->urgent, window->urgent, >)) {
148 return false;
149 }
150 }
151 LOG("urgent matches latest\n");
152 }
153
154 if (match->urgent == U_OLDEST) {
155 /* if the window isn't urgent, no sense in searching */
156 if (window->urgent.tv_sec == 0) {
157 return false;
158 }
159 /* if we find a window that is older than this one (and not 0), bail */
161 if ((con->window != NULL) &&
162 (con->window->urgent.tv_sec != 0) &&
163 _i3_timercmp(con->window->urgent, window->urgent, <)) {
164 return false;
165 }
166 }
167 LOG("urgent matches oldest\n");
168 }
169
170 if (match->workspace != NULL) {
171 if ((con = con_by_window_id(window->id)) == NULL) {
172 return false;
173 }
174
175 Con *ws = con_get_workspace(con);
176 if (ws == NULL) {
177 return false;
178 }
179
180 if (strcmp(match->workspace->pattern, "__focused__") == 0 &&
181 strcmp(ws->name, con_get_workspace(focused)->name) == 0) {
182 LOG("workspace matches focused workspace\n");
183 } else if (regex_matches(match->workspace, ws->name)) {
184 LOG("workspace matches (%s)\n", ws->name);
185 } else {
186 return false;
187 }
188 }
189
190 if (match->dock != M_DONTCHECK) {
191 if ((window->dock == W_DOCK_TOP && match->dock == M_DOCK_TOP) ||
192 (window->dock == W_DOCK_BOTTOM && match->dock == M_DOCK_BOTTOM) ||
193 ((window->dock == W_DOCK_TOP || window->dock == W_DOCK_BOTTOM) &&
194 match->dock == M_DOCK_ANY) ||
195 (window->dock == W_NODOCK && match->dock == M_NODOCK)) {
196 LOG("dock status matches\n");
197 } else {
198 LOG("dock status does not match\n");
199 return false;
200 }
201 }
202
203 if (match->mark != NULL) {
204 if ((con = con_by_window_id(window->id)) == NULL) {
205 return false;
206 }
207
208 bool matched = false;
209 mark_t *mark;
210 TAILQ_FOREACH (mark, &(con->marks_head), marks) {
211 if (regex_matches(match->mark, mark->name)) {
212 matched = true;
213 break;
214 }
215 }
216
217 if (matched) {
218 LOG("mark matches\n");
219 } else {
220 LOG("mark does not match\n");
221 return false;
222 }
223 }
224
225 if (match->window_mode != WM_ANY) {
226 if ((con = con_by_window_id(window->id)) == NULL) {
227 return false;
228 }
229
230 switch (match->window_mode) {
231 case WM_TILING_AUTO:
232 if (con->floating != FLOATING_AUTO_OFF) {
233 return false;
234 }
235 break;
236 case WM_TILING_USER:
237 if (con->floating != FLOATING_USER_OFF) {
238 return false;
239 }
240 break;
241 case WM_TILING:
242 if (con_inside_floating(con) != NULL) {
243 return false;
244 }
245 break;
246 case WM_FLOATING_AUTO:
247 if (con->floating != FLOATING_AUTO_ON) {
248 return false;
249 }
250 break;
251 case WM_FLOATING_USER:
252 if (con->floating != FLOATING_USER_ON) {
253 return false;
254 }
255 break;
256 case WM_FLOATING:
257 if (con_inside_floating(con) == NULL) {
258 return false;
259 }
260 break;
261 case WM_ANY:
262 assert(false);
263 }
264
265 LOG("window_mode matches\n");
266 }
267
268 /* NOTE: See the comment regarding 'all' in match_parse_property()
269 * for an explanation of why match_all_windows isn't explicitly
270 * checked. */
271
272 return true;
273}
274
275/*
276 * Frees the given match. It must not be used afterwards!
277 *
278 */
279void match_free(Match *match) {
280 FREE(match->error);
281 regex_free(match->title);
282 regex_free(match->application);
283 regex_free(match->class);
284 regex_free(match->instance);
285 regex_free(match->mark);
286 regex_free(match->window_role);
287 regex_free(match->workspace);
288 regex_free(match->machine);
289}
290
291/*
292 * Interprets a ctype=cvalue pair and adds it to the given match specification.
293 *
294 */
295void match_parse_property(Match *match, const char *ctype, const char *cvalue) {
296 assert(match != NULL);
297 DLOG("ctype=*%s*, cvalue=*%s*\n", ctype, cvalue);
298
299 if (strcmp(ctype, "class") == 0) {
300 regex_free(match->class);
301 match->class = regex_new(cvalue);
302 return;
303 }
304
305 if (strcmp(ctype, "instance") == 0) {
306 regex_free(match->instance);
307 match->instance = regex_new(cvalue);
308 return;
309 }
310
311 if (strcmp(ctype, "window_role") == 0) {
312 regex_free(match->window_role);
313 match->window_role = regex_new(cvalue);
314 return;
315 }
316
317 if (strcmp(ctype, "con_id") == 0) {
318 if (strcmp(cvalue, "__focused__") == 0) {
319 match->con_id = focused;
320 return;
321 }
322
323 long parsed;
324 if (!parse_long(cvalue, &parsed, 0)) {
325 ELOG("Could not parse con id \"%s\"\n", cvalue);
326 match->error = sstrdup("invalid con_id");
327 } else {
328 match->con_id = (Con *)parsed;
329 DLOG("id as int = %p\n", match->con_id);
330 }
331 return;
332 }
333
334 if (strcmp(ctype, "id") == 0) {
335 long parsed;
336 if (!parse_long(cvalue, &parsed, 0)) {
337 ELOG("Could not parse window id \"%s\"\n", cvalue);
338 match->error = sstrdup("invalid id");
339 } else {
340 match->id = parsed;
341 DLOG("window id as int = %d\n", match->id);
342 }
343 return;
344 }
345
346 if (strcmp(ctype, "window_type") == 0) {
347 if (strcasecmp(cvalue, "normal") == 0) {
348 match->window_type = A__NET_WM_WINDOW_TYPE_NORMAL;
349 } else if (strcasecmp(cvalue, "dialog") == 0) {
350 match->window_type = A__NET_WM_WINDOW_TYPE_DIALOG;
351 } else if (strcasecmp(cvalue, "utility") == 0) {
352 match->window_type = A__NET_WM_WINDOW_TYPE_UTILITY;
353 } else if (strcasecmp(cvalue, "toolbar") == 0) {
354 match->window_type = A__NET_WM_WINDOW_TYPE_TOOLBAR;
355 } else if (strcasecmp(cvalue, "splash") == 0) {
356 match->window_type = A__NET_WM_WINDOW_TYPE_SPLASH;
357 } else if (strcasecmp(cvalue, "menu") == 0) {
358 match->window_type = A__NET_WM_WINDOW_TYPE_MENU;
359 } else if (strcasecmp(cvalue, "dropdown_menu") == 0) {
360 match->window_type = A__NET_WM_WINDOW_TYPE_DROPDOWN_MENU;
361 } else if (strcasecmp(cvalue, "popup_menu") == 0) {
362 match->window_type = A__NET_WM_WINDOW_TYPE_POPUP_MENU;
363 } else if (strcasecmp(cvalue, "tooltip") == 0) {
364 match->window_type = A__NET_WM_WINDOW_TYPE_TOOLTIP;
365 } else if (strcasecmp(cvalue, "notification") == 0) {
366 match->window_type = A__NET_WM_WINDOW_TYPE_NOTIFICATION;
367 } else {
368 ELOG("unknown window_type value \"%s\"\n", cvalue);
369 match->error = sstrdup("unknown window_type value");
370 }
371
372 return;
373 }
374
375 if (strcmp(ctype, "con_mark") == 0) {
376 regex_free(match->mark);
377 match->mark = regex_new(cvalue);
378 return;
379 }
380
381 if (strcmp(ctype, "title") == 0) {
382 regex_free(match->title);
383 match->title = regex_new(cvalue);
384 return;
385 }
386
387 if (strcmp(ctype, "urgent") == 0) {
388 if (strcasecmp(cvalue, "latest") == 0 ||
389 strcasecmp(cvalue, "newest") == 0 ||
390 strcasecmp(cvalue, "recent") == 0 ||
391 strcasecmp(cvalue, "last") == 0) {
392 match->urgent = U_LATEST;
393 } else if (strcasecmp(cvalue, "oldest") == 0 ||
394 strcasecmp(cvalue, "first") == 0) {
395 match->urgent = U_OLDEST;
396 }
397 return;
398 }
399
400 if (strcmp(ctype, "workspace") == 0) {
401 regex_free(match->workspace);
402 match->workspace = regex_new(cvalue);
403 return;
404 }
405
406 if (strcmp(ctype, "machine") == 0) {
407 regex_free(match->machine);
408 match->machine = regex_new(cvalue);
409 return;
410 }
411
412 if (strcmp(ctype, "tiling") == 0) {
413 match->window_mode = WM_TILING;
414 return;
415 }
416
417 if (strcmp(ctype, "tiling_from") == 0 &&
418 cvalue != NULL &&
419 strcmp(cvalue, "auto") == 0) {
420 match->window_mode = WM_TILING_AUTO;
421 return;
422 }
423
424 if (strcmp(ctype, "tiling_from") == 0 &&
425 cvalue != NULL &&
426 strcmp(cvalue, "user") == 0) {
427 match->window_mode = WM_TILING_USER;
428 return;
429 }
430
431 if (strcmp(ctype, "floating") == 0) {
432 match->window_mode = WM_FLOATING;
433 return;
434 }
435
436 if (strcmp(ctype, "floating_from") == 0 &&
437 cvalue != NULL &&
438 strcmp(cvalue, "auto") == 0) {
439 match->window_mode = WM_FLOATING_AUTO;
440 return;
441 }
442
443 if (strcmp(ctype, "floating_from") == 0 &&
444 cvalue != NULL &&
445 strcmp(cvalue, "user") == 0) {
446 match->window_mode = WM_FLOATING_USER;
447 return;
448 }
449
450 /* match_matches_window() only checks negatively, so match_all_windows
451 * won't actually be used there, but that's OK because if no negative
452 * match is found (e.g. because of a more restrictive criterion) the
453 * return value of match_matches_window() is true.
454 * Setting it here only serves to cause match_is_empty() to return false,
455 * otherwise empty criteria rules apply, and that's not what we want. */
456 if (strcmp(ctype, "all") == 0) {
457 match->match_all_windows = true;
458 return;
459 }
460
461 ELOG("Unknown criterion: %s\n", ctype);
462}
Con * con_get_workspace(Con *con)
Gets the workspace container this node is on.
Definition con.c:547
Con * con_by_window_id(xcb_window_t window)
Returns the container with the given client window ID or NULL if no such container exists.
Definition con.c:752
Con * con_inside_floating(Con *con)
Checks if the given container is either floating or inside some floating container.
Definition con.c:696
struct pending_marks * marks
#define _i3_timercmp(a, b, CMP)
Definition match.c:17
#define DUPLICATE_REGEX(field)
bool match_is_empty(Match *match)
Check if a match is empty.
Definition match.c:39
void match_init(Match *match)
Initializes the Match data structure.
Definition match.c:26
void match_copy(Match *dest, Match *src)
Copies the data of a match from src to dest.
Definition match.c:64
void match_free(Match *match)
Frees the given match.
Definition match.c:279
bool match_matches_window(Match *match, i3Window *window)
Check if a match data structure matches the given window.
Definition match.c:90
void match_parse_property(Match *match, const char *ctype, const char *cvalue)
Interprets a ctype=cvalue pair and adds it to the given match specification.
Definition match.c:295
#define CHECK_WINDOW_FIELD(match_field, window_field, type)
bool regex_matches(struct regex *regex, const char *input)
Checks if the given regular expression matches the given input and returns true if it does.
Definition regex.c:62
void regex_free(struct regex *regex)
Frees the given regular expression.
Definition regex.c:47
struct regex * regex_new(const char *pattern)
Creates a new 'regex' struct containing the given pattern and a PCRE compiled regular expression.
Definition regex.c:22
struct Con * focused
Definition tree.c:13
struct all_cons_head all_cons
Definition tree.c:15
bool parse_long(const char *str, long *out, int base)
Converts a string into a long using strtol().
Definition util.c:419
#define DLOG(fmt,...)
Definition libi3.h:105
#define LOG(fmt,...)
Definition libi3.h:95
char * sstrdup(const char *str)
Safe-wrapper around strdup which exits if malloc returns NULL (meaning that there is no more memory a...
#define ELOG(fmt,...)
Definition libi3.h:100
#define TAILQ_FOREACH(var, head, field)
Definition queue.h:347
#define FREE(pointer)
Definition util.h:47
char * pattern
Definition data.h:281
A 'Window' is a type which contains an xcb_window_t and all the related information (hints like _NET_...
Definition data.h:424
struct timeval urgent
When this window was marked urgent.
Definition data.h:476
xcb_window_t id
Definition data.h:425
enum Window::@11 dock
Whether the window says it is a dock window.
xcb_atom_t window_type
The _NET_WM_WINDOW_TYPE for this window.
Definition data.h:465
char * class_class
Definition data.h:437
A "match" is a data structure which acts like a mask or expression to match certain windows or not.
Definition data.h:529
struct regex * window_role
Definition data.h:538
bool match_all_windows
Definition data.h:563
xcb_atom_t window_type
Definition data.h:541
struct regex * title
Definition data.h:533
struct regex * instance
Definition data.h:536
enum Match::@12 urgent
struct regex * application
Definition data.h:534
enum Match::@14 window_mode
struct regex * mark
Definition data.h:537
struct regex * machine
Definition data.h:540
struct regex * workspace
Definition data.h:539
xcb_window_t id
Definition data.h:554
Con * con_id
Definition data.h:562
char * error
Definition data.h:531
struct regex * class
Definition data.h:535
enum Match::@13 dock
Definition data.h:633
char * name
Definition data.h:634
A 'Con' represents everything from the X11 root window down to a single X11 window.
Definition data.h:643
struct Window * window
Definition data.h:718
char * name
Definition data.h:692
enum Con::@19 floating
floating? (= not in tiling layout) This cannot be simply a bool because we want to keep track of whet...