]> git.lizzy.rs Git - bspwm.git/blob - src/query.c
d98ece03e142c728c03bf8b3a293c9785dec6993
[bspwm.git] / src / query.c
1 /* Copyright (c) 2012, Bastien Dejean
2  * All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are met:
6  *
7  * 1. Redistributions of source code must retain the above copyright notice, this
8  *    list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright notice,
10  *    this list of conditions and the following disclaimer in the documentation
11  *    and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
17  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
20  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include "bspwm.h"
29 #include "desktop.h"
30 #include "history.h"
31 #include "parse.h"
32 #include "monitor.h"
33 #include "window.h"
34 #include "tree.h"
35 #include "query.h"
36 #include "geometry.h"
37
38 void query_state(FILE *rsp)
39 {
40         fprintf(rsp, "{");
41         fprintf(rsp, "\"focusedMonitorId\":%u,", mon->id);
42         if (pri_mon != NULL) {
43                 fprintf(rsp, "\"primaryMonitorId\":%u,", pri_mon->id);
44         }
45         fprintf(rsp, "\"clientsCount\":%i,", clients_count);
46         fprintf(rsp, "\"monitors\":");
47         fprintf(rsp, "[");
48         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
49                 query_monitor(m, rsp);
50                 if (m->next != NULL) {
51                         fprintf(rsp, ",");
52                 }
53         }
54         fprintf(rsp, "]");
55         fprintf(rsp,",");
56         fprintf(rsp, "\"focusHistory\":");
57         query_history(rsp);
58         fprintf(rsp,",");
59         fprintf(rsp, "\"stackingList\":");
60         query_stack(rsp);
61         if (restart) {
62                 fprintf(rsp,",");
63                 fprintf(rsp, "\"eventSubscribers\":");
64                 query_subscribers(rsp);
65         }
66         fprintf(rsp, "}");
67 }
68
69 void query_monitor(monitor_t *m, FILE *rsp)
70 {
71         fprintf(rsp, "{");
72         fprintf(rsp, "\"name\":\"%s\",", m->name);
73         fprintf(rsp, "\"id\":%u,", m->id);
74         fprintf(rsp, "\"randrId\":%u,", m->randr_id);
75         fprintf(rsp, "\"wired\":%s,", BOOL_STR(m->wired));
76         fprintf(rsp, "\"stickyCount\":%i,", m->sticky_count);
77         fprintf(rsp, "\"windowGap\":%i,", m->window_gap);
78         fprintf(rsp, "\"borderWidth\":%u,", m->border_width);
79         fprintf(rsp, "\"focusedDesktopId\":%u,", m->desk->id);
80         fprintf(rsp, "\"padding\":");
81         query_padding(m->padding, rsp);
82         fprintf(rsp,",");
83         fprintf(rsp, "\"rectangle\":");
84         query_rectangle(m->rectangle, rsp);
85         fprintf(rsp,",");
86         fprintf(rsp, "\"desktops\":");
87         fprintf(rsp, "[");
88         for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
89                 query_desktop(d, rsp);
90                 if (d->next != NULL) {
91                         fprintf(rsp,",");
92                 }
93         }
94         fprintf(rsp, "]");
95         fprintf(rsp, "}");
96 }
97
98 void query_desktop(desktop_t *d, FILE *rsp)
99 {
100         fprintf(rsp, "{");
101         fprintf(rsp, "\"name\":\"%s\",", d->name);
102         fprintf(rsp, "\"id\":%u,", d->id);
103         fprintf(rsp, "\"layout\":\"%s\",", LAYOUT_STR(d->layout));
104         fprintf(rsp, "\"userLayout\":\"%s\",", LAYOUT_STR(d->user_layout));
105         fprintf(rsp, "\"windowGap\":%i,", d->window_gap);
106         fprintf(rsp, "\"borderWidth\":%u,", d->border_width);
107         fprintf(rsp, "\"focusedNodeId\":%u,", d->focus != NULL ? d->focus->id : 0);
108         fprintf(rsp, "\"padding\":");
109         query_padding(d->padding, rsp);
110         fprintf(rsp,",");
111         fprintf(rsp, "\"root\":");
112         query_node(d->root, rsp);
113         fprintf(rsp, "}");
114 }
115
116 void query_node(node_t *n, FILE *rsp)
117 {
118         if (n == NULL) {
119                 fprintf(rsp, "null");
120         } else {
121                 fprintf(rsp, "{");
122                 fprintf(rsp, "\"id\":%u,", n->id);
123                 fprintf(rsp, "\"splitType\":\"%s\",", SPLIT_TYPE_STR(n->split_type));
124                 fprintf(rsp, "\"splitRatio\":%lf,", n->split_ratio);
125                 fprintf(rsp, "\"vacant\":%s,", BOOL_STR(n->vacant));
126                 fprintf(rsp, "\"hidden\":%s,", BOOL_STR(n->hidden));
127                 fprintf(rsp, "\"sticky\":%s,", BOOL_STR(n->sticky));
128                 fprintf(rsp, "\"private\":%s,", BOOL_STR(n->private));
129                 fprintf(rsp, "\"locked\":%s,", BOOL_STR(n->locked));
130                 fprintf(rsp, "\"marked\":%s,", BOOL_STR(n->marked));
131                 fprintf(rsp, "\"presel\":");
132                 query_presel(n->presel, rsp);
133                 fprintf(rsp,",");
134                 fprintf(rsp, "\"rectangle\":");
135                 query_rectangle(n->rectangle, rsp);
136                 fprintf(rsp,",");
137                 fprintf(rsp, "\"constraints\":");
138                 query_constraints(n->constraints, rsp);
139                 fprintf(rsp,",");
140                 fprintf(rsp, "\"firstChild\":");
141                 query_node(n->first_child, rsp);
142                 fprintf(rsp,",");
143                 fprintf(rsp, "\"secondChild\":");
144                 query_node(n->second_child, rsp);
145                 fprintf(rsp,",");
146                 fprintf(rsp, "\"client\":");
147                 query_client(n->client, rsp);
148                 fprintf(rsp, "}");
149         }
150 }
151
152 void query_presel(presel_t *p, FILE *rsp)
153 {
154         if (p == NULL) {
155                 fprintf(rsp, "null");
156         } else {
157                 fprintf(rsp, "{\"splitDir\":\"%s\",\"splitRatio\":%lf}", SPLIT_DIR_STR(p->split_dir), p->split_ratio);
158         }
159 }
160
161 void query_client(client_t *c, FILE *rsp)
162 {
163         if (c == NULL) {
164                 fprintf(rsp, "null");
165         } else {
166                 fprintf(rsp, "{");
167                 fprintf(rsp, "\"className\":\"%s\",", c->class_name);
168                 fprintf(rsp, "\"instanceName\":\"%s\",", c->instance_name);
169                 fprintf(rsp, "\"borderWidth\":%u,", c->border_width);
170                 fprintf(rsp, "\"state\":\"%s\",", STATE_STR(c->state));
171                 fprintf(rsp, "\"lastState\":\"%s\",", STATE_STR(c->last_state));
172                 fprintf(rsp, "\"layer\":\"%s\",", LAYER_STR(c->layer));
173                 fprintf(rsp, "\"lastLayer\":\"%s\",", LAYER_STR(c->last_layer));
174                 fprintf(rsp, "\"urgent\":%s,", BOOL_STR(c->urgent));
175                 fprintf(rsp, "\"shown\":%s,", BOOL_STR(c->shown));
176                 fprintf(rsp, "\"tiledRectangle\":");
177                 query_rectangle(c->tiled_rectangle, rsp);
178                 fprintf(rsp,",");
179                 fprintf(rsp, "\"floatingRectangle\":");
180                 query_rectangle(c->floating_rectangle, rsp);
181                 fprintf(rsp, "}");
182         }
183 }
184
185 void query_rectangle(xcb_rectangle_t r, FILE *rsp)
186 {
187         fprintf(rsp, "{\"x\":%i,\"y\":%i,\"width\":%u,\"height\":%u}", r.x, r.y, r.width, r.height);
188 }
189
190 void query_constraints(constraints_t c, FILE *rsp)
191 {
192         fprintf(rsp, "{\"min_width\":%u,\"min_height\":%u}", c.min_width, c.min_height);
193 }
194
195 void query_padding(padding_t p, FILE *rsp)
196 {
197         fprintf(rsp, "{\"top\":%i,\"right\":%i,\"bottom\":%i,\"left\":%i}", p.top, p.right, p.bottom, p.left);
198 }
199
200 void query_history(FILE *rsp)
201 {
202         fprintf(rsp, "[");
203         for (history_t *h = history_head; h != NULL; h = h->next) {
204                 query_coordinates(&h->loc, rsp);
205                 if (h->next != NULL) {
206                         fprintf(rsp, ",");
207                 }
208         }
209         fprintf(rsp, "]");
210 }
211
212 void query_coordinates(coordinates_t *loc, FILE *rsp)
213 {
214         fprintf(rsp, "{\"monitorId\":%u,\"desktopId\":%u,\"nodeId\":%u}", loc->monitor->id, loc->desktop->id, loc->node!=NULL?loc->node->id:0);
215 }
216
217 void query_stack(FILE *rsp)
218 {
219         fprintf(rsp, "[");
220         for (stacking_list_t *s = stack_head; s != NULL; s = s->next) {
221                 fprintf(rsp, "%u", s->node->id);
222                 if (s->next != NULL) {
223                         fprintf(rsp, ",");
224                 }
225         }
226         fprintf(rsp, "]");
227 }
228
229 void query_subscribers(FILE *rsp)
230 {
231         fprintf(rsp, "[");
232         for (subscriber_list_t *s = subscribe_head; s != NULL; s = s->next) {
233                 fprintf(rsp, "{\"fileDescriptor\": %i", fileno(s->stream));
234                 if (s->fifo_path != NULL) {
235                         fprintf(rsp, ",\"fifoPath\":\"%s\"", s->fifo_path);
236                 }
237                 fprintf(rsp, ",\"field\":%i,\"count\":%i}", s->field, s->count);
238                 if (s->next != NULL) {
239                         fprintf(rsp, ",");
240                 }
241         }
242         fprintf(rsp, "]");
243 }
244
245 int query_node_ids(coordinates_t *ref, coordinates_t *trg, monitor_select_t *mon_sel, desktop_select_t *desk_sel, node_select_t *sel, FILE *rsp)
246 {
247         int count = 0;
248         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
249                 coordinates_t loc = {m, NULL, NULL};
250                 if ((trg->monitor != NULL && m != trg->monitor) ||
251                     (mon_sel != NULL && !monitor_matches(&loc, ref, mon_sel))) {
252                         continue;
253                 }
254                 for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
255                         coordinates_t loc = {m, d, NULL};
256                         if ((trg->desktop != NULL && d != trg->desktop) ||
257                             (desk_sel != NULL && !desktop_matches(&loc, ref, desk_sel))) {
258                                 continue;
259                         }
260                         count += query_node_ids_in(d->root, d, m, ref, trg, sel, rsp);
261                 }
262         }
263         return count;
264 }
265
266 int query_node_ids_in(node_t *n, desktop_t *d, monitor_t *m, coordinates_t *ref, coordinates_t *trg, node_select_t *sel, FILE *rsp)
267 {
268         int count = 0;
269         if (n == NULL) {
270                 return 0;
271         } else {
272                 coordinates_t loc = {m, d, n};
273                 if ((trg->node == NULL || n == trg->node) &&
274                     (sel == NULL || node_matches(&loc, ref, sel))) {
275                         fprintf(rsp, "0x%08X\n", n->id);
276                         count++;
277                 }
278                 count += query_node_ids_in(n->first_child, d, m, ref, trg, sel, rsp);
279                 count += query_node_ids_in(n->second_child, d, m, ref, trg, sel, rsp);
280         }
281         return count;
282 }
283
284 int query_desktop_ids(coordinates_t *ref, coordinates_t *trg, monitor_select_t *mon_sel, desktop_select_t *sel, desktop_printer_t printer, FILE *rsp)
285 {
286         int count = 0;
287         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
288                 coordinates_t loc = {m, NULL, NULL};
289                 if ((trg->monitor != NULL && m != trg->monitor) ||
290                     (mon_sel != NULL && !monitor_matches(&loc, ref, mon_sel))) {
291                         continue;
292                 }
293                 for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
294                         coordinates_t loc = {m, d, NULL};
295                         if ((trg->desktop != NULL && d != trg->desktop) ||
296                             (sel != NULL && !desktop_matches(&loc, ref, sel))) {
297                                 continue;
298                         }
299                         printer(d, rsp);
300                         count++;
301                 }
302         }
303         return count;
304 }
305
306 int query_monitor_ids(coordinates_t *ref, coordinates_t *trg, monitor_select_t *sel, monitor_printer_t printer, FILE *rsp)
307 {
308         int count = 0;
309         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
310                 coordinates_t loc = {m, NULL, NULL};
311                 if ((trg->monitor != NULL && m != trg->monitor) ||
312                     (sel != NULL && !monitor_matches(&loc, ref, sel))) {
313                         continue;
314                 }
315                 printer(m, rsp);
316                 count++;
317         }
318         return count;
319 }
320
321 void fprint_monitor_id(monitor_t *m, FILE *rsp)
322 {
323         fprintf(rsp, "0x%08X\n", m->id);
324 }
325
326 void fprint_monitor_name(monitor_t *m, FILE *rsp)
327 {
328         fprintf(rsp, "%s\n", m->name);
329 }
330
331 void fprint_desktop_id(desktop_t *d, FILE *rsp)
332 {
333         fprintf(rsp, "0x%08X\n", d->id);
334 }
335
336 void fprint_desktop_name(desktop_t *d, FILE *rsp)
337 {
338         fprintf(rsp, "%s\n", d->name);
339 }
340
341 void print_ignore_request(state_transition_t st, FILE *rsp)
342 {
343         if (st == 0) {
344                 fprintf(rsp, "none");
345         } else {
346                 unsigned int cnt = 0;
347                 if (st & STATE_TRANSITION_ENTER) {
348                         fprintf(rsp, "enter");
349                         cnt++;
350                 }
351                 if (st & STATE_TRANSITION_EXIT) {
352                         fprintf(rsp, "%sexit", cnt > 0 ? "," : "");
353                 }
354         }
355 }
356
357 void print_modifier_mask(uint16_t m, FILE *rsp)
358 {
359         switch (m) {
360                 case XCB_MOD_MASK_SHIFT:
361                         fprintf(rsp, "shift");
362                         break;
363                 case XCB_MOD_MASK_CONTROL:
364                         fprintf(rsp, "control");
365                         break;
366                 case XCB_MOD_MASK_LOCK:
367                         fprintf(rsp, "lock");
368                         break;
369                 case XCB_MOD_MASK_1:
370                         fprintf(rsp, "mod1");
371                         break;
372                 case XCB_MOD_MASK_2:
373                         fprintf(rsp, "mod2");
374                         break;
375                 case XCB_MOD_MASK_3:
376                         fprintf(rsp, "mod3");
377                         break;
378                 case XCB_MOD_MASK_4:
379                         fprintf(rsp, "mod4");
380                         break;
381                 case XCB_MOD_MASK_5:
382                         fprintf(rsp, "mod5");
383                         break;
384         }
385 }
386
387 void print_button_index(int8_t b, FILE *rsp)
388 {
389         switch (b) {
390                 case XCB_BUTTON_INDEX_ANY:
391                         fprintf(rsp, "any");
392                         break;
393                 case XCB_BUTTON_INDEX_1:
394                         fprintf(rsp, "button1");
395                         break;
396                 case XCB_BUTTON_INDEX_2:
397                         fprintf(rsp, "button2");
398                         break;
399                 case XCB_BUTTON_INDEX_3:
400                         fprintf(rsp, "button3");
401                         break;
402                 case -1:
403                         fprintf(rsp, "none");
404                         break;
405         }
406 }
407
408 void print_pointer_action(pointer_action_t a, FILE *rsp)
409 {
410         switch (a) {
411                 case ACTION_MOVE:
412                         fprintf(rsp, "move");
413                         break;
414                 case ACTION_RESIZE_SIDE:
415                         fprintf(rsp, "resize_side");
416                         break;
417                 case ACTION_RESIZE_CORNER:
418                         fprintf(rsp, "resize_corner");
419                         break;
420                 case ACTION_FOCUS:
421                         fprintf(rsp, "focus");
422                         break;
423                 case ACTION_NONE:
424                         fprintf(rsp, "none");
425                         break;
426         }
427 }
428
429 void print_rule_consequence(char **buf, rule_consequence_t *csq)
430 {
431         char *rect_buf = NULL;
432         print_rectangle(&rect_buf, csq->rect);
433         if (rect_buf == NULL) {
434                 rect_buf = malloc(1);
435                 *rect_buf = '\0';
436         }
437         asprintf(buf, "monitor=%s desktop=%s node=%s state=%s layer=%s split_dir=%s split_ratio=%lf hidden=%s sticky=%s private=%s locked=%s marked=%s center=%s follow=%s manage=%s focus=%s border=%s rectangle=%s",
438                 csq->monitor_desc, csq->desktop_desc, csq->node_desc,
439                 csq->state == NULL ? "" : STATE_STR(*csq->state),
440                 csq->layer == NULL ? "" : LAYER_STR(*csq->layer),
441                 csq->split_dir == NULL ? "" : SPLIT_DIR_STR(*csq->split_dir), csq->split_ratio,
442                 ON_OFF_STR(csq->hidden), ON_OFF_STR(csq->sticky), ON_OFF_STR(csq->private),
443                 ON_OFF_STR(csq->locked), ON_OFF_STR(csq->marked), ON_OFF_STR(csq->center), ON_OFF_STR(csq->follow),
444                 ON_OFF_STR(csq->manage), ON_OFF_STR(csq->focus), ON_OFF_STR(csq->border), rect_buf);
445         free(rect_buf);
446 }
447
448 void print_rectangle(char **buf, xcb_rectangle_t *rect)
449 {
450         if (rect != NULL) {
451                 asprintf(buf, "%hux%hu+%hi+%hi", rect->width, rect->height, rect->x, rect->y);
452         }
453 }
454
455 node_select_t make_node_select(void)
456 {
457         node_select_t sel = {
458                 .automatic = OPTION_NONE,
459                 .focused = OPTION_NONE,
460                 .active = OPTION_NONE,
461                 .local = OPTION_NONE,
462                 .leaf = OPTION_NONE,
463                 .window = OPTION_NONE,
464                 .tiled = OPTION_NONE,
465                 .pseudo_tiled = OPTION_NONE,
466                 .floating = OPTION_NONE,
467                 .fullscreen = OPTION_NONE,
468                 .hidden = OPTION_NONE,
469                 .sticky = OPTION_NONE,
470                 .private = OPTION_NONE,
471                 .locked = OPTION_NONE,
472                 .marked = OPTION_NONE,
473                 .urgent = OPTION_NONE,
474                 .same_class = OPTION_NONE,
475                 .descendant_of = OPTION_NONE,
476                 .ancestor_of = OPTION_NONE,
477                 .below = OPTION_NONE,
478                 .normal = OPTION_NONE,
479                 .above = OPTION_NONE,
480                 .horizontal = OPTION_NONE,
481                 .vertical = OPTION_NONE
482         };
483         return sel;
484 }
485
486 desktop_select_t make_desktop_select(void)
487 {
488         desktop_select_t sel = {
489                 .occupied = OPTION_NONE,
490                 .focused = OPTION_NONE,
491                 .active = OPTION_NONE,
492                 .urgent = OPTION_NONE,
493                 .local = OPTION_NONE
494         };
495         return sel;
496 }
497
498 monitor_select_t make_monitor_select(void)
499 {
500         monitor_select_t sel = {
501                 .occupied = OPTION_NONE,
502                 .focused = OPTION_NONE
503         };
504         return sel;
505 }
506
507 int node_from_desc(char *desc, coordinates_t *ref, coordinates_t *dst)
508 {
509         coordinates_t ref_copy = *ref;
510         ref = &ref_copy;
511         char *desc_copy = copy_string(desc, strlen(desc));
512         desc = desc_copy;
513
514         char *hash = strrchr(desc, '#');
515         char *path = strrchr(desc, '@');
516         char *colon = strrchr(desc, ':');
517
518         /* Discard hashes inside a DESKTOP_SEL */
519         if (hash != NULL && colon != NULL && path != NULL &&
520             path < hash && hash < colon) {
521                 if (path > desc && *(path - 1) == '#') {
522                         hash = path - 1;
523                 } else {
524                         hash = NULL;
525                 }
526         }
527
528         if (hash != NULL) {
529                 *hash = '\0';
530                 int ret;
531                 coordinates_t tmp = {mon, mon->desk, mon->desk->focus};
532                 if ((ret = node_from_desc(desc, &tmp, ref)) == SELECTOR_OK) {
533                         desc = hash + 1;
534                 } else {
535                         free(desc_copy);
536                         return ret;
537                 }
538         }
539
540         node_select_t sel = make_node_select();
541
542         if (!parse_node_modifiers(colon != NULL ? colon : desc, &sel)) {
543                 free(desc_copy);
544                 return SELECTOR_BAD_MODIFIERS;
545         }
546
547         dst->node = NULL;
548
549         direction_t dir;
550         cycle_dir_t cyc;
551         history_dir_t hdi;
552         if (parse_direction(desc, &dir)) {
553                 find_nearest_neighbor(ref, dst, dir, &sel);
554         } else if (parse_cycle_direction(desc, &cyc)) {
555                 find_closest_node(ref, dst, cyc, &sel);
556         } else if (parse_history_direction(desc, &hdi)) {
557                 history_find_node(hdi, ref, dst, &sel);
558         } else if (streq("any", desc)) {
559                 find_any_node(ref, dst, &sel);
560         } else if (streq("first_ancestor", desc)) {
561                 find_first_ancestor(ref, dst, &sel);
562         } else if (streq("last", desc)) {
563                 history_find_node(HISTORY_OLDER, ref, dst, &sel);
564         } else if (streq("newest", desc)) {
565                 history_find_newest_node(ref, dst, &sel);
566         } else if (streq("biggest", desc)) {
567                 find_by_area(AREA_BIGGEST, ref, dst, &sel);
568         } else if (streq("smallest", desc)) {
569                 find_by_area(AREA_SMALLEST, ref, dst, &sel);
570         } else if (streq("pointed", desc)) {
571                 xcb_window_t win = XCB_NONE;
572                 query_pointer(&win, NULL);
573                 if (locate_leaf(win, dst) && node_matches(dst, ref, &sel)) {
574                         return SELECTOR_OK;
575                 } else {
576                         return SELECTOR_INVALID;
577                 }
578         } else if (streq("focused", desc)) {
579                 coordinates_t loc = {mon, mon->desk, mon->desk->focus};
580                 if (node_matches(&loc, ref, &sel)) {
581                         *dst = loc;
582                 }
583         } else if (*desc == '@') {
584                 desc++;
585                 *dst = *ref;
586                 if (colon != NULL) {
587                         *colon = '\0';
588                         int ret;
589                         if ((ret = desktop_from_desc(desc, ref, dst)) == SELECTOR_OK) {
590                                 dst->node = dst->desktop->focus;
591                                 desc = colon + 1;
592                         } else {
593                                 free(desc_copy);
594                                 return ret;
595                         }
596                 }
597                 if (*desc == '/') {
598                         dst->node = dst->desktop->root;
599                 }
600                 char *move = strtok(desc, PTH_TOK);
601                 while (move != NULL && dst->node != NULL) {
602                         if (streq("first", move) || streq("1", move)) {
603                                 dst->node = dst->node->first_child;
604                         } else if (streq("second", move) || streq("2", move)) {
605                                 dst->node = dst->node->second_child;
606                         } else if (streq("parent", move)) {
607                                 dst->node = dst->node->parent;
608                         } else if (streq("brother", move)) {
609                                 dst->node = brother_tree(dst->node);
610                         } else {
611                                 direction_t dir;
612                                 if (parse_direction(move, &dir)) {
613                                         dst->node = find_fence(dst->node, dir);
614                                 } else {
615                                         free(desc_copy);
616                                         return SELECTOR_BAD_DESCRIPTOR;
617                                 }
618                         }
619                         move = strtok(NULL, PTH_TOK);
620                 }
621                 free(desc_copy);
622                 if (dst->node != NULL) {
623                         if (node_matches(dst, ref, &sel)) {
624                                 return SELECTOR_OK;
625                         } else {
626                                 return SELECTOR_INVALID;
627                         }
628                 } else if (dst->desktop->root != NULL) {
629                         return SELECTOR_INVALID;
630                 }
631                 return SELECTOR_OK;
632         } else {
633                 uint32_t id;
634                 if (parse_id(desc, &id)) {
635                         free(desc_copy);
636                         if (find_by_id(id, dst) && node_matches(dst, ref, &sel)) {
637                                 return SELECTOR_OK;
638                         } else {
639                                 return SELECTOR_INVALID;
640                         }
641                 } else {
642                         free(desc_copy);
643                         return SELECTOR_BAD_DESCRIPTOR;
644                 }
645         }
646
647         free(desc_copy);
648
649         if (dst->node == NULL) {
650                 return SELECTOR_INVALID;
651         }
652
653         return SELECTOR_OK;
654 }
655
656 int desktop_from_desc(char *desc, coordinates_t *ref, coordinates_t *dst)
657 {
658         if (*desc == '%') {
659                 locate_desktop(desc + 1, dst);
660                 goto end;
661         }
662
663         coordinates_t ref_copy = *ref;
664         ref = &ref_copy;
665         char *desc_copy = copy_string(desc, strlen(desc));
666         desc = desc_copy;
667
668         char *hash = strrchr(desc, '#');
669
670         if (hash != NULL) {
671                 *hash = '\0';
672                 int ret;
673                 coordinates_t tmp = {mon, mon->desk, NULL};
674                 if ((ret = desktop_from_desc(desc, &tmp, ref)) == SELECTOR_OK) {
675                         desc = hash + 1;
676                 } else {
677                         free(desc_copy);
678                         return ret;
679                 }
680         }
681
682         desktop_select_t sel = make_desktop_select();
683         char *colon = strrchr(desc, ':');
684
685         if (!parse_desktop_modifiers(colon != NULL ? colon : desc, &sel)) {
686                 free(desc_copy);
687                 return SELECTOR_BAD_MODIFIERS;
688         }
689
690         dst->desktop = NULL;
691
692         cycle_dir_t cyc;
693         history_dir_t hdi;
694         uint16_t idx;
695         uint32_t id;
696         if (parse_cycle_direction(desc, &cyc)) {
697                 find_closest_desktop(ref, dst, cyc, &sel);
698         } else if (parse_history_direction(desc, &hdi)) {
699                 history_find_desktop(hdi, ref, dst, &sel);
700         } else if (streq("any", desc)) {
701                 find_any_desktop(ref, dst, &sel);
702         } else if (streq("last", desc)) {
703                 history_find_desktop(HISTORY_OLDER, ref, dst, &sel);
704         } else if (streq("newest", desc)) {
705                 history_find_newest_desktop(ref, dst, &sel);
706         } else if (streq("focused", desc)) {
707                 coordinates_t loc = {mon, mon->desk, NULL};
708                 if (desktop_matches(&loc, ref, &sel)) {
709                         *dst = loc;
710                 }
711         } else if (colon != NULL) {
712                 *colon = '\0';
713                 int ret;
714                 if ((ret = monitor_from_desc(desc, ref, dst)) == SELECTOR_OK) {
715                         if (streq("focused", colon + 1)) {
716                                 coordinates_t loc = {dst->monitor, dst->monitor->desk, NULL};
717                                 if (desktop_matches(&loc, ref, &sel)) {
718                                         *dst = loc;
719                                 }
720                         } else if (parse_index(colon + 1, &idx)) {
721                                 free(desc_copy);
722                                 if (desktop_from_index(idx, dst, dst->monitor) && desktop_matches(dst, ref, &sel)) {
723                                         return SELECTOR_OK;
724                                 } else {
725                                         return SELECTOR_INVALID;
726                                 }
727                         } else {
728                                 free(desc_copy);
729                                 return SELECTOR_BAD_DESCRIPTOR;
730                         }
731                 } else {
732                         free(desc_copy);
733                         return ret;
734                 }
735         } else if (parse_index(desc, &idx) && desktop_from_index(idx, dst, NULL)) {
736                 free(desc_copy);
737                 if (desktop_matches(dst, ref, &sel)) {
738                         return SELECTOR_OK;
739                 } else {
740                         return SELECTOR_INVALID;
741                 }
742         } else if (parse_id(desc, &id) && desktop_from_id(id, dst, NULL)) {
743                 free(desc_copy);
744                 if (desktop_matches(dst, ref, &sel)) {
745                         return SELECTOR_OK;
746                 } else {
747                         return SELECTOR_INVALID;
748                 }
749         } else {
750                 int hits = 0;
751                 if (desktop_from_name(desc, ref, dst, &sel, &hits)) {
752                         free(desc_copy);
753                         return SELECTOR_OK;
754                 } else {
755                         free(desc_copy);
756                         if (hits > 0) {
757                                 return SELECTOR_INVALID;
758                         } else {
759                                 return SELECTOR_BAD_DESCRIPTOR;
760                         }
761                 }
762         }
763
764         free(desc_copy);
765
766 end:
767         if (dst->desktop == NULL) {
768                 return SELECTOR_INVALID;
769         }
770
771         return SELECTOR_OK;
772 }
773
774 int monitor_from_desc(char *desc, coordinates_t *ref, coordinates_t *dst)
775 {
776         if (*desc == '%') {
777                 locate_monitor(desc + 1, dst);
778                 goto end;
779         }
780
781         coordinates_t ref_copy = *ref;
782         ref = &ref_copy;
783         char *desc_copy = copy_string(desc, strlen(desc));
784         desc = desc_copy;
785
786         char *hash = strrchr(desc, '#');
787
788         if (hash != NULL) {
789                 *hash = '\0';
790                 int ret;
791                 coordinates_t tmp = {mon, NULL, NULL};
792                 if ((ret = monitor_from_desc(desc, &tmp, ref)) == SELECTOR_OK) {
793                         desc = hash + 1;
794                 } else {
795                         free(desc_copy);
796                         return ret;
797                 }
798         }
799
800         monitor_select_t sel = make_monitor_select();
801
802         if (!parse_monitor_modifiers(desc, &sel)) {
803                 free(desc_copy);
804                 return SELECTOR_BAD_MODIFIERS;
805         }
806
807         dst->monitor = NULL;
808
809         direction_t dir;
810         cycle_dir_t cyc;
811         history_dir_t hdi;
812         uint16_t idx;
813         uint32_t id;
814         if (parse_direction(desc, &dir)) {
815                 dst->monitor = nearest_monitor(ref->monitor, dir, &sel);
816         } else if (parse_cycle_direction(desc, &cyc)) {
817                 dst->monitor = closest_monitor(ref->monitor, cyc, &sel);
818         } else if (parse_history_direction(desc, &hdi)) {
819                 history_find_monitor(hdi, ref, dst, &sel);
820         } else if (streq("any", desc)) {
821                 find_any_monitor(ref, dst, &sel);
822         } else if (streq("last", desc)) {
823                 history_find_monitor(HISTORY_OLDER, ref, dst, &sel);
824         } else if (streq("newest", desc)) {
825                 history_find_newest_monitor(ref, dst, &sel);
826         } else if (streq("primary", desc)) {
827                 if (pri_mon != NULL) {
828                         coordinates_t loc = {pri_mon, NULL, NULL};
829                         if (monitor_matches(&loc, ref, &sel)) {
830                                 dst->monitor = pri_mon;
831                         }
832                 }
833         } else if (streq("focused", desc)) {
834                 coordinates_t loc = {mon, NULL, NULL};
835                 if (monitor_matches(&loc, ref, &sel)) {
836                         dst->monitor = mon;
837                 }
838         } else if (streq("pointed", desc)) {
839                 xcb_point_t pointer;
840                 query_pointer(NULL, &pointer);
841                 for (monitor_t *m = mon_head; m != NULL; m = m->next) {
842                         if (is_inside(pointer, m->rectangle)) {
843                                 dst->monitor = m;
844                                 break;
845                         }
846                 }
847         } else if (parse_index(desc, &idx) && monitor_from_index(idx, dst)) {
848                 free(desc_copy);
849                 if (monitor_matches(dst, ref, &sel)) {
850                         return SELECTOR_OK;
851                 } else {
852                         return SELECTOR_INVALID;
853                 }
854         } else if (parse_id(desc, &id) && monitor_from_id(id, dst)) {
855                 free(desc_copy);
856                 if (monitor_matches(dst, ref, &sel)) {
857                         return SELECTOR_OK;
858                 } else {
859                         return SELECTOR_INVALID;
860                 }
861         } else {
862                 if (locate_monitor(desc, dst)) {
863                         free(desc_copy);
864                         if (monitor_matches(dst, ref, &sel)) {
865                                 return SELECTOR_OK;
866                         } else {
867                                 return SELECTOR_INVALID;
868                         }
869                 } else {
870                         free(desc_copy);
871                         return SELECTOR_BAD_DESCRIPTOR;
872                 }
873         }
874
875         free(desc_copy);
876
877 end:
878         if (dst->monitor == NULL) {
879                 return SELECTOR_INVALID;
880         }
881
882         return SELECTOR_OK;
883 }
884
885 bool locate_leaf(xcb_window_t win, coordinates_t *loc)
886 {
887         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
888                 for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
889                         for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root)) {
890                                 if (n->id == win) {
891                                         loc->monitor = m;
892                                         loc->desktop = d;
893                                         loc->node = n;
894                                         return true;
895                                 }
896                         }
897                 }
898         }
899         return false;
900 }
901
902 bool locate_window(xcb_window_t win, coordinates_t *loc)
903 {
904         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
905                 for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
906                         for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root)) {
907                                 if (n->client == NULL) {
908                                         continue;
909                                 }
910                                 if (n->id == win) {
911                                         loc->monitor = m;
912                                         loc->desktop = d;
913                                         loc->node = n;
914                                         return true;
915                                 }
916                         }
917                 }
918         }
919         return false;
920 }
921
922 bool locate_desktop(char *name, coordinates_t *loc)
923 {
924         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
925                 for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
926                         if (streq(d->name, name)) {
927                                 loc->monitor = m;
928                                 loc->desktop = d;
929                                 return true;
930                         }
931                 }
932         }
933         return false;
934 }
935
936 bool locate_monitor(char *name, coordinates_t *loc)
937 {
938         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
939                 if (streq(m->name, name)) {
940                         loc->monitor = m;
941                         return true;
942                 }
943         }
944         return false;
945 }
946
947 bool desktop_from_id(uint32_t id, coordinates_t *loc, monitor_t *mm)
948 {
949         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
950                 if (mm != NULL && m != mm) {
951                         continue;
952                 }
953                 for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
954                         if (d->id == id) {
955                                 loc->monitor = m;
956                                 loc->desktop = d;
957                                 loc->node = NULL;
958                                 return true;
959                         }
960                 }
961         }
962         return false;
963 }
964
965 bool desktop_from_name(char *name, coordinates_t *ref, coordinates_t *dst, desktop_select_t *sel, int *hits)
966 {
967         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
968                 for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
969                         if (streq(d->name, name)) {
970                                 if (hits != NULL) {
971                                         (*hits)++;
972                                 }
973                                 coordinates_t loc = {m, d, NULL};
974                                 if (desktop_matches(&loc, ref, sel)) {
975                                         dst->monitor = m;
976                                         dst->desktop = d;
977                                         return true;
978                                 }
979                         }
980                 }
981         }
982         return false;
983 }
984
985 bool desktop_from_index(uint16_t idx, coordinates_t *loc, monitor_t *mm)
986 {
987         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
988                 if (mm != NULL && m != mm) {
989                         continue;
990                 }
991                 for (desktop_t *d = m->desk_head; d != NULL; d = d->next, idx--) {
992                         if (idx == 1) {
993                                 loc->monitor = m;
994                                 loc->desktop = d;
995                                 loc->node = NULL;
996                                 return true;
997                         }
998                 }
999         }
1000         return false;
1001 }
1002
1003 bool monitor_from_id(uint32_t id, coordinates_t *loc)
1004 {
1005         for (monitor_t *m = mon_head; m != NULL; m = m->next) {
1006                 if (m->id == id) {
1007                         loc->monitor = m;
1008                         loc->desktop = NULL;
1009                         loc->node = NULL;
1010                         return true;
1011                 }
1012         }
1013         return false;
1014 }
1015
1016 bool monitor_from_index(int idx, coordinates_t *loc)
1017 {
1018         for (monitor_t *m = mon_head; m != NULL; m = m->next, idx--) {
1019                 if (idx == 1) {
1020                         loc->monitor = m;
1021                         loc->desktop = NULL;
1022                         loc->node = NULL;
1023                         return true;
1024                 }
1025         }
1026         return false;
1027 }
1028
1029 bool node_matches(coordinates_t *loc, coordinates_t *ref, node_select_t *sel)
1030 {
1031         if (loc->node == NULL) {
1032                 return false;
1033         }
1034
1035         if (sel->focused != OPTION_NONE &&
1036             loc->node != mon->desk->focus
1037             ? sel->focused == OPTION_TRUE
1038             : sel->focused == OPTION_FALSE) {
1039                 return false;
1040         }
1041
1042         if (sel->active != OPTION_NONE &&
1043             loc->node != loc->desktop->focus
1044             ? sel->active == OPTION_TRUE
1045             : sel->active == OPTION_FALSE) {
1046                 return false;
1047         }
1048
1049         if (sel->automatic != OPTION_NONE &&
1050             loc->node->presel != NULL
1051             ? sel->automatic == OPTION_TRUE
1052             : sel->automatic == OPTION_FALSE) {
1053                 return false;
1054         }
1055
1056         if (sel->local != OPTION_NONE &&
1057             loc->desktop != ref->desktop
1058             ? sel->local == OPTION_TRUE
1059             : sel->local == OPTION_FALSE) {
1060                 return false;
1061         }
1062
1063         if (sel->active != OPTION_NONE &&
1064             loc->desktop != loc->monitor->desk
1065             ? sel->active == OPTION_TRUE
1066             : sel->active == OPTION_FALSE) {
1067                 return false;
1068         }
1069
1070         if (sel->leaf != OPTION_NONE &&
1071             !is_leaf(loc->node)
1072             ? sel->leaf == OPTION_TRUE
1073             : sel->leaf == OPTION_FALSE) {
1074                 return false;
1075         }
1076
1077         if (sel->window != OPTION_NONE &&
1078             loc->node->client == NULL
1079             ? sel->window == OPTION_TRUE
1080             : sel->window == OPTION_FALSE) {
1081                 return false;
1082         }
1083
1084 #define NFLAG(p) \
1085         if (sel->p != OPTION_NONE && \
1086             !loc->node->p \
1087             ? sel->p == OPTION_TRUE \
1088             : sel->p == OPTION_FALSE) { \
1089                 return false; \
1090         }
1091         NFLAG(hidden)
1092         NFLAG(sticky)
1093         NFLAG(private)
1094         NFLAG(locked)
1095         NFLAG(marked)
1096 #undef NFLAG
1097
1098         if (loc->node->client == NULL &&
1099                 (sel->same_class != OPTION_NONE ||
1100                  sel->tiled != OPTION_NONE ||
1101                  sel->pseudo_tiled != OPTION_NONE ||
1102                  sel->floating != OPTION_NONE ||
1103                  sel->fullscreen != OPTION_NONE ||
1104                  sel->below != OPTION_NONE ||
1105                  sel->normal != OPTION_NONE ||
1106                  sel->above != OPTION_NONE ||
1107                  sel->urgent != OPTION_NONE)) {
1108                 return false;
1109         }
1110
1111         if (ref->node != NULL && ref->node->client != NULL &&
1112             sel->same_class != OPTION_NONE &&
1113             streq(loc->node->client->class_name, ref->node->client->class_name)
1114             ? sel->same_class == OPTION_FALSE
1115             : sel->same_class == OPTION_TRUE) {
1116                 return false;
1117         }
1118
1119         if (sel->descendant_of != OPTION_NONE &&
1120             !is_descendant(loc->node, ref->node)
1121             ? sel->descendant_of == OPTION_TRUE
1122             : sel->descendant_of == OPTION_FALSE) {
1123                 return false;
1124         }
1125
1126         if (sel->ancestor_of != OPTION_NONE &&
1127             !is_descendant(ref->node, loc->node)
1128             ? sel->ancestor_of == OPTION_TRUE
1129             : sel->ancestor_of == OPTION_FALSE) {
1130                 return false;
1131         }
1132
1133 #define WSTATE(p, e) \
1134         if (sel->p != OPTION_NONE && \
1135             loc->node->client->state != e \
1136             ? sel->p == OPTION_TRUE \
1137             : sel->p == OPTION_FALSE) { \
1138                 return false; \
1139         }
1140         WSTATE(tiled, STATE_TILED)
1141         WSTATE(pseudo_tiled, STATE_PSEUDO_TILED)
1142         WSTATE(floating, STATE_FLOATING)
1143         WSTATE(fullscreen, STATE_FULLSCREEN)
1144 #undef WSTATE
1145
1146 #define WLAYER(p, e) \
1147         if (sel->p != OPTION_NONE && \
1148             loc->node->client->layer != e \
1149             ? sel->p == OPTION_TRUE \
1150             : sel->p == OPTION_FALSE) { \
1151                 return false; \
1152         }
1153         WLAYER(below, LAYER_BELOW)
1154         WLAYER(normal, LAYER_NORMAL)
1155         WLAYER(above, LAYER_ABOVE)
1156 #undef WLAYER
1157
1158 #define WFLAG(p) \
1159         if (sel->p != OPTION_NONE && \
1160             !loc->node->client->p \
1161             ? sel->p == OPTION_TRUE \
1162             : sel->p == OPTION_FALSE) { \
1163                 return false; \
1164         }
1165         WFLAG(urgent)
1166 #undef WFLAG
1167
1168         if (sel->horizontal != OPTION_NONE &&
1169             loc->node->split_type != TYPE_HORIZONTAL
1170             ? sel->horizontal == OPTION_TRUE
1171             : sel->horizontal == OPTION_FALSE) {
1172                 return false;
1173         }
1174
1175         if (sel->vertical != OPTION_NONE &&
1176             loc->node->split_type != TYPE_VERTICAL
1177             ? sel->vertical == OPTION_TRUE
1178             : sel->vertical == OPTION_FALSE) {
1179                 return false;
1180         }
1181
1182         return true;
1183 }
1184
1185 bool desktop_matches(coordinates_t *loc, coordinates_t *ref, desktop_select_t *sel)
1186 {
1187         if (sel->occupied != OPTION_NONE &&
1188             loc->desktop->root == NULL
1189             ? sel->occupied == OPTION_TRUE
1190             : sel->occupied == OPTION_FALSE) {
1191                 return false;
1192         }
1193
1194         if (sel->focused != OPTION_NONE &&
1195             loc->desktop != mon->desk
1196             ? sel->focused == OPTION_TRUE
1197             : sel->focused == OPTION_FALSE) {
1198                 return false;
1199         }
1200
1201         if (sel->active != OPTION_NONE &&
1202             loc->desktop != loc->monitor->desk
1203             ? sel->active == OPTION_TRUE
1204             : sel->active == OPTION_FALSE) {
1205                 return false;
1206         }
1207
1208         if (sel->urgent != OPTION_NONE &&
1209             !is_urgent(loc->desktop)
1210             ? sel->urgent == OPTION_TRUE
1211             : sel->urgent == OPTION_FALSE) {
1212                 return false;
1213         }
1214
1215         if (sel->local != OPTION_NONE &&
1216             ref->monitor != loc->monitor
1217             ? sel->local == OPTION_TRUE
1218             : sel->local == OPTION_FALSE) {
1219                 return false;
1220         }
1221
1222         return true;
1223 }
1224
1225 bool monitor_matches(coordinates_t *loc, __attribute__((unused)) coordinates_t *ref, monitor_select_t *sel)
1226 {
1227         if (sel->occupied != OPTION_NONE &&
1228             loc->monitor->desk->root == NULL
1229             ? sel->occupied == OPTION_TRUE
1230             : sel->occupied == OPTION_FALSE) {
1231                 return false;
1232         }
1233
1234         if (sel->focused != OPTION_NONE &&
1235             loc->monitor != mon
1236             ? sel->focused == OPTION_TRUE
1237             : sel->focused == OPTION_FALSE) {
1238                 return false;
1239         }
1240
1241         return true;
1242 }