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