git.sur5r.net Git - i3/i3/blob - src/commands.c

   1 /*
   2  * vim:ts=4:sw=4:expandtab
   3  *
   4  * i3 - an improved dynamic tiling window manager
   5  * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
   6  *
   7  * commands.c: all command functions (see commands_parser.c)
   8  *
   9  */
  10 #include "all.h"
  11
  12 #include <stdint.h>
  13 #include <float.h>
  14 #include <stdarg.h>
  15
  16 #ifdef I3_ASAN_ENABLED
  17 #include <sanitizer/lsan_interface.h>
  18 #endif
  19
  20 #include "shmlog.h"
  21
  22 // Macros to make the YAJL API a bit easier to use.
  23 #define y(x, ...) (cmd_output->json_gen != NULL ? yajl_gen_##x(cmd_output->json_gen, ##__VA_ARGS__) : 0)
  24 #define ystr(str) (cmd_output->json_gen != NULL ? yajl_gen_string(cmd_output->json_gen, (unsigned char *)str, strlen(str)) : 0)
  25 #define ysuccess(success)                   \
  26     do {                                    \
  27         if (cmd_output->json_gen != NULL) { \
  28             y(map_open);                    \
  29             ystr("success");                \
  30             y(bool, success);               \
  31             y(map_close);                   \
  32         }                                   \
  33     } while (0)
  34 #define yerror(format, ...)                             \
  35     do {                                                \
  36         if (cmd_output->json_gen != NULL) {             \
  37             char *message;                              \
  38             sasprintf(&message, format, ##__VA_ARGS__); \
  39             y(map_open);                                \
  40             ystr("success");                            \
  41             y(bool, false);                             \
  42             ystr("error");                              \
  43             ystr(message);                              \
  44             y(map_close);                               \
  45             free(message);                              \
  46         }                                               \
  47     } while (0)
  48
  49 /** If an error occurred during parsing of the criteria, we want to exit instead
  50  * of relying on fallback behavior. See #2091. */
  51 #define HANDLE_INVALID_MATCH                                   \
  52     do {                                                       \
  53         if (current_match->error != NULL) {                    \
  54             yerror("Invalid match: %s", current_match->error); \
  55             return;                                            \
  56         }                                                      \
  57     } while (0)
  58
  59 /** When the command did not include match criteria (!), we use the currently
  60  * focused container. Do not confuse this case with a command which included
  61  * criteria but which did not match any windows. This macro has to be called in
  62  * every command.
  63  */
  64 #define HANDLE_EMPTY_MATCH                              \
  65     do {                                                \
  66         HANDLE_INVALID_MATCH;                           \
  67                                                         \
  68         if (match_is_empty(current_match)) {            \
  69             while (!TAILQ_EMPTY(&owindows)) {           \
  70                 owindow *ow = TAILQ_FIRST(&owindows);   \
  71                 TAILQ_REMOVE(&owindows, ow, owindows);  \
  72                 free(ow);                               \
  73             }                                           \
  74             owindow *ow = smalloc(sizeof(owindow));     \
  75             ow->con = focused;                          \
  76             TAILQ_INIT(&owindows);                      \
  77             TAILQ_INSERT_TAIL(&owindows, ow, owindows); \
  78         }                                               \
  79     } while (0)
  80
  81 /*
  82  * Returns true if a is definitely greater than b (using the given epsilon)
  83  *
  84  */
  85 static bool definitelyGreaterThan(float a, float b, float epsilon) {
  86     return (a - b) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
  87 }
  88
  89 /*
  90  * Checks whether we switched to a new workspace and returns false in that case,
  91  * signaling that further workspace switching should be done by the calling function
  92  * If not, calls workspace_back_and_forth() if workspace_auto_back_and_forth is set
  93  * and return true, signaling that no further workspace switching should occur in the calling function.
  94  *
  95  */
  96 static bool maybe_back_and_forth(struct CommandResultIR *cmd_output, const char *name) {
  97     Con *ws = con_get_workspace(focused);
  98
  99     /* If we switched to a different workspace, do nothing */
 100     if (strcmp(ws->name, name) != 0)
 101         return false;
 102
 103     DLOG("This workspace is already focused.\n");
 104     if (config.workspace_auto_back_and_forth) {
 105         workspace_back_and_forth();
 106         cmd_output->needs_tree_render = true;
 107     }
 108     return true;
 109 }
 110
 111 /*
 112  * Return the passed workspace unless it is the current one and auto back and
 113  * forth is enabled, in which case the back_and_forth workspace is returned.
 114  */
 115 static Con *maybe_auto_back_and_forth_workspace(Con *workspace) {
 116     Con *current, *baf;
 117
 118     if (!config.workspace_auto_back_and_forth)
 119         return workspace;
 120
 121     current = con_get_workspace(focused);
 122
 123     if (current == workspace) {
 124         baf = workspace_back_and_forth_get();
 125         if (baf != NULL) {
 126             DLOG("Substituting workspace with back_and_forth, as it is focused.\n");
 127             return baf;
 128         }
 129     }
 130
 131     return workspace;
 132 }
 133
 134 /*******************************************************************************
 135  * Criteria functions.
 136  ******************************************************************************/
 137
 138 /*
 139  * Helper data structure for an operation window (window on which the operation
 140  * will be performed). Used to build the TAILQ owindows.
 141  *
 142  */
 143 typedef struct owindow {
 144     Con *con;
 145
 146     TAILQ_ENTRY(owindow)
 147     owindows;
 148 } owindow;
 149
 150 typedef TAILQ_HEAD(owindows_head, owindow) owindows_head;
 151
 152 static owindows_head owindows;
 153
 154 /*
 155  * Initializes the specified 'Match' data structure and the initial state of
 156  * commands.c for matching target windows of a command.
 157  *
 158  */
 159 void cmd_criteria_init(I3_CMD) {
 160     Con *con;
 161     owindow *ow;
 162
 163     DLOG("Initializing criteria, current_match = %p\n", current_match);
 164     match_free(current_match);
 165     match_init(current_match);
 166     while (!TAILQ_EMPTY(&owindows)) {
 167         ow = TAILQ_FIRST(&owindows);
 168         TAILQ_REMOVE(&owindows, ow, owindows);
 169         free(ow);
 170     }
 171     TAILQ_INIT(&owindows);
 172     /* copy all_cons */
 173     TAILQ_FOREACH(con, &all_cons, all_cons) {
 174         ow = smalloc(sizeof(owindow));
 175         ow->con = con;
 176         TAILQ_INSERT_TAIL(&owindows, ow, owindows);
 177     }
 178 }
 179
 180 /*
 181  * A match specification just finished (the closing square bracket was found),
 182  * so we filter the list of owindows.
 183  *
 184  */
 185 void cmd_criteria_match_windows(I3_CMD) {
 186     owindow *next, *current;
 187
 188     DLOG("match specification finished, matching...\n");
 189     /* copy the old list head to iterate through it and start with a fresh
 190      * list which will contain only matching windows */
 191     struct owindows_head old = owindows;
 192     TAILQ_INIT(&owindows);
 193     for (next = TAILQ_FIRST(&old); next != TAILQ_END(&old);) {
 194         /* make a copy of the next pointer and advance the pointer to the
 195          * next element as we are going to invalidate the element’s
 196          * next/prev pointers by calling TAILQ_INSERT_TAIL later */
 197         current = next;
 198         next = TAILQ_NEXT(next, owindows);
 199
 200         DLOG("checking if con %p / %s matches\n", current->con, current->con->name);
 201
 202         /* We use this flag to prevent matching on window-less containers if
 203          * only window-specific criteria were specified. */
 204         bool accept_match = false;
 205
 206         if (current_match->con_id != NULL) {
 207             accept_match = true;
 208
 209             if (current_match->con_id == current->con) {
 210                 DLOG("con_id matched.\n");
 211             } else {
 212                 DLOG("con_id does not match.\n");
 213                 FREE(current);
 214                 continue;
 215             }
 216         }
 217
 218         if (current_match->mark != NULL && !TAILQ_EMPTY(&(current->con->marks_head))) {
 219             accept_match = true;
 220             bool matched_by_mark = false;
 221
 222             mark_t *mark;
 223             TAILQ_FOREACH(mark, &(current->con->marks_head), marks) {
 224                 if (!regex_matches(current_match->mark, mark->name))
 225                     continue;
 226
 227                 DLOG("match by mark\n");
 228                 matched_by_mark = true;
 229                 break;
 230             }
 231
 232             if (!matched_by_mark) {
 233                 DLOG("mark does not match.\n");
 234                 FREE(current);
 235                 continue;
 236             }
 237         }
 238
 239         if (current->con->window != NULL) {
 240             if (match_matches_window(current_match, current->con->window)) {
 241                 DLOG("matches window!\n");
 242                 accept_match = true;
 243             } else {
 244                 DLOG("doesn't match\n");
 245                 FREE(current);
 246                 continue;
 247             }
 248         }
 249
 250         if (accept_match) {
 251             TAILQ_INSERT_TAIL(&owindows, current, owindows);
 252         } else {
 253             FREE(current);
 254             continue;
 255         }
 256     }
 257
 258     TAILQ_FOREACH(current, &owindows, owindows) {
 259         DLOG("matching: %p / %s\n", current->con, current->con->name);
 260     }
 261 }
 262
 263 /*
 264  * Interprets a ctype=cvalue pair and adds it to the current match
 265  * specification.
 266  *
 267  */
 268 void cmd_criteria_add(I3_CMD, const char *ctype, const char *cvalue) {
 269     match_parse_property(current_match, ctype, cvalue);
 270 }
 271
 272 /*
 273  * Implementation of 'move [window|container] [to] workspace
 274  * next|prev|next_on_output|prev_on_output|current'.
 275  *
 276  */
 277 void cmd_move_con_to_workspace(I3_CMD, const char *which) {
 278     owindow *current;
 279
 280     DLOG("which=%s\n", which);
 281
 282     /* We have nothing to move:
 283      *  when criteria was specified but didn't match any window or
 284      *  when criteria wasn't specified and we don't have any window focused. */
 285     if ((!match_is_empty(current_match) && TAILQ_EMPTY(&owindows)) ||
 286         (match_is_empty(current_match) && focused->type == CT_WORKSPACE &&
 287          !con_has_children(focused))) {
 288         ysuccess(false);
 289         return;
 290     }
 291
 292     HANDLE_EMPTY_MATCH;
 293
 294     /* get the workspace */
 295     Con *ws;
 296     if (strcmp(which, "next") == 0)
 297         ws = workspace_next();
 298     else if (strcmp(which, "prev") == 0)
 299         ws = workspace_prev();
 300     else if (strcmp(which, "next_on_output") == 0)
 301         ws = workspace_next_on_output();
 302     else if (strcmp(which, "prev_on_output") == 0)
 303         ws = workspace_prev_on_output();
 304     else if (strcmp(which, "current") == 0)
 305         ws = con_get_workspace(focused);
 306     else {
 307         ELOG("BUG: called with which=%s\n", which);
 308         ysuccess(false);
 309         return;
 310     }
 311
 312     TAILQ_FOREACH(current, &owindows, owindows) {
 313         DLOG("matching: %p / %s\n", current->con, current->con->name);
 314         con_move_to_workspace(current->con, ws, true, false, false);
 315     }
 316
 317     cmd_output->needs_tree_render = true;
 318     // XXX: default reply for now, make this a better reply
 319     ysuccess(true);
 320 }
 321
 322 /**
 323  * Implementation of 'move [window|container] [to] workspace back_and_forth'.
 324  *
 325  */
 326 void cmd_move_con_to_workspace_back_and_forth(I3_CMD) {
 327     owindow *current;
 328     Con *ws;
 329
 330     ws = workspace_back_and_forth_get();
 331
 332     if (ws == NULL) {
 333         yerror("No workspace was previously active.");
 334         return;
 335     }
 336
 337     HANDLE_EMPTY_MATCH;
 338
 339     TAILQ_FOREACH(current, &owindows, owindows) {
 340         DLOG("matching: %p / %s\n", current->con, current->con->name);
 341         con_move_to_workspace(current->con, ws, true, false, false);
 342     }
 343
 344     cmd_output->needs_tree_render = true;
 345     // XXX: default reply for now, make this a better reply
 346     ysuccess(true);
 347 }
 348
 349 /*
 350  * Implementation of 'move [--no-auto-back-and-forth] [window|container] [to] workspace <name>'.
 351  *
 352  */
 353 void cmd_move_con_to_workspace_name(I3_CMD, const char *name, const char *_no_auto_back_and_forth) {
 354     if (strncasecmp(name, "__", strlen("__")) == 0) {
 355         LOG("You cannot move containers to i3-internal workspaces (\"%s\").\n", name);
 356         ysuccess(false);
 357         return;
 358     }
 359
 360     const bool no_auto_back_and_forth = (_no_auto_back_and_forth != NULL);
 361     owindow *current;
 362
 363     /* We have nothing to move:
 364      *  when criteria was specified but didn't match any window or
 365      *  when criteria wasn't specified and we don't have any window focused. */
 366     if (!match_is_empty(current_match) && TAILQ_EMPTY(&owindows)) {
 367         ELOG("No windows match your criteria, cannot move.\n");
 368         ysuccess(false);
 369         return;
 370     } else if (match_is_empty(current_match) && focused->type == CT_WORKSPACE &&
 371                !con_has_children(focused)) {
 372         ysuccess(false);
 373         return;
 374     }
 375
 376     LOG("should move window to workspace %s\n", name);
 377     /* get the workspace */
 378     Con *ws = workspace_get(name, NULL);
 379
 380     if (!no_auto_back_and_forth)
 381         ws = maybe_auto_back_and_forth_workspace(ws);
 382
 383     HANDLE_EMPTY_MATCH;
 384
 385     TAILQ_FOREACH(current, &owindows, owindows) {
 386         DLOG("matching: %p / %s\n", current->con, current->con->name);
 387         con_move_to_workspace(current->con, ws, true, false, false);
 388     }
 389
 390     cmd_output->needs_tree_render = true;
 391     // XXX: default reply for now, make this a better reply
 392     ysuccess(true);
 393 }
 394
 395 /*
 396  * Implementation of 'move [--no-auto-back-and-forth] [window|container] [to] workspace number <name>'.
 397  *
 398  */
 399 void cmd_move_con_to_workspace_number(I3_CMD, const char *which, const char *_no_auto_back_and_forth) {
 400     const bool no_auto_back_and_forth = (_no_auto_back_and_forth != NULL);
 401     owindow *current;
 402
 403     /* We have nothing to move:
 404      *  when criteria was specified but didn't match any window or
 405      *  when criteria wasn't specified and we don't have any window focused. */
 406     if ((!match_is_empty(current_match) && TAILQ_EMPTY(&owindows)) ||
 407         (match_is_empty(current_match) && focused->type == CT_WORKSPACE &&
 408          !con_has_children(focused))) {
 409         ysuccess(false);
 410         return;
 411     }
 412
 413     LOG("should move window to workspace %s\n", which);
 414     /* get the workspace */
 415     Con *output, *workspace = NULL;
 416
 417     long parsed_num = ws_name_to_number(which);
 418
 419     if (parsed_num == -1) {
 420         LOG("Could not parse initial part of \"%s\" as a number.\n", which);
 421         yerror("Could not parse number \"%s\"", which);
 422         return;
 423     }
 424
 425     TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
 426     GREP_FIRST(workspace, output_get_content(output),
 427                child->num == parsed_num);
 428
 429     if (!workspace) {
 430         workspace = workspace_get(which, NULL);
 431     }
 432
 433     if (!no_auto_back_and_forth)
 434         workspace = maybe_auto_back_and_forth_workspace(workspace);
 435
 436     HANDLE_EMPTY_MATCH;
 437
 438     TAILQ_FOREACH(current, &owindows, owindows) {
 439         DLOG("matching: %p / %s\n", current->con, current->con->name);
 440         con_move_to_workspace(current->con, workspace, true, false, false);
 441     }
 442
 443     cmd_output->needs_tree_render = true;
 444     // XXX: default reply for now, make this a better reply
 445     ysuccess(true);
 446 }
 447
 448 static void cmd_resize_floating(I3_CMD, const char *way, const char *direction, Con *floating_con, int px) {
 449     LOG("floating resize\n");
 450     Rect old_rect = floating_con->rect;
 451     Con *focused_con = con_descend_focused(floating_con);
 452
 453     /* ensure that resize will take place even if pixel increment is smaller than
 454      * height increment or width increment.
 455      * fixes #1011 */
 456     const i3Window *window = focused_con->window;
 457     if (window != NULL) {
 458         if (strcmp(direction, "up") == 0 || strcmp(direction, "down") == 0 ||
 459             strcmp(direction, "height") == 0) {
 460             if (px < 0)
 461                 px = (-px < window->height_increment) ? -window->height_increment : px;
 462             else
 463                 px = (px < window->height_increment) ? window->height_increment : px;
 464         } else if (strcmp(direction, "left") == 0 || strcmp(direction, "right") == 0) {
 465             if (px < 0)
 466                 px = (-px < window->width_increment) ? -window->width_increment : px;
 467             else
 468                 px = (px < window->width_increment) ? window->width_increment : px;
 469         }
 470     }
 471
 472     if (strcmp(direction, "up") == 0) {
 473         floating_con->rect.height += px;
 474     } else if (strcmp(direction, "down") == 0 || strcmp(direction, "height") == 0) {
 475         floating_con->rect.height += px;
 476     } else if (strcmp(direction, "left") == 0) {
 477         floating_con->rect.width += px;
 478     } else {
 479         floating_con->rect.width += px;
 480     }
 481
 482     floating_check_size(floating_con);
 483
 484     /* Did we actually resize anything or did the size constraints prevent us?
 485      * If we could not resize, exit now to not move the window. */
 486     if (memcmp(&old_rect, &(floating_con->rect), sizeof(Rect)) == 0)
 487         return;
 488
 489     if (strcmp(direction, "up") == 0) {
 490         floating_con->rect.y -= (floating_con->rect.height - old_rect.height);
 491     } else if (strcmp(direction, "left") == 0) {
 492         floating_con->rect.x -= (floating_con->rect.width - old_rect.width);
 493     }
 494
 495     /* If this is a scratchpad window, don't auto center it from now on. */
 496     if (floating_con->scratchpad_state == SCRATCHPAD_FRESH)
 497         floating_con->scratchpad_state = SCRATCHPAD_CHANGED;
 498 }
 499
 500 static bool cmd_resize_tiling_direction(I3_CMD, Con *current, const char *way, const char *direction, int ppt) {
 501     LOG("tiling resize\n");
 502     Con *second = NULL;
 503     Con *first = current;
 504     direction_t search_direction;
 505     if (!strcmp(direction, "left"))
 506         search_direction = D_LEFT;
 507     else if (!strcmp(direction, "right"))
 508         search_direction = D_RIGHT;
 509     else if (!strcmp(direction, "up"))
 510         search_direction = D_UP;
 511     else
 512         search_direction = D_DOWN;
 513
 514     bool res = resize_find_tiling_participants(&first, &second, search_direction, false);
 515     if (!res) {
 516         LOG("No second container in this direction found.\n");
 517         ysuccess(false);
 518         return false;
 519     }
 520
 521     /* get the default percentage */
 522     int children = con_num_children(first->parent);
 523     LOG("ins. %d children\n", children);
 524     double percentage = 1.0 / children;
 525     LOG("default percentage = %f\n", percentage);
 526
 527     /* resize */
 528     LOG("second->percent = %f\n", second->percent);
 529     LOG("first->percent before = %f\n", first->percent);
 530     if (first->percent == 0.0)
 531         first->percent = percentage;
 532     if (second->percent == 0.0)
 533         second->percent = percentage;
 534     double new_first_percent = first->percent + ((double)ppt / 100.0);
 535     double new_second_percent = second->percent - ((double)ppt / 100.0);
 536     LOG("new_first_percent = %f\n", new_first_percent);
 537     LOG("new_second_percent = %f\n", new_second_percent);
 538     /* Ensure that the new percentages are positive and greater than
 539      * 0.05 to have a reasonable minimum size. */
 540     if (definitelyGreaterThan(new_first_percent, 0.05, DBL_EPSILON) &&
 541         definitelyGreaterThan(new_second_percent, 0.05, DBL_EPSILON)) {
 542         first->percent += ((double)ppt / 100.0);
 543         second->percent -= ((double)ppt / 100.0);
 544         LOG("first->percent after = %f\n", first->percent);
 545         LOG("second->percent after = %f\n", second->percent);
 546     } else {
 547         LOG("Not resizing, already at minimum size\n");
 548     }
 549
 550     return true;
 551 }
 552
 553 static bool cmd_resize_tiling_width_height(I3_CMD, Con *current, const char *way, const char *direction, int ppt) {
 554     LOG("width/height resize\n");
 555
 556     /* get the appropriate current container (skip stacked/tabbed cons) */
 557     Con *dummy = NULL;
 558     direction_t search_direction = (strcmp(direction, "width") == 0 ? D_LEFT : D_DOWN);
 559     bool search_result = resize_find_tiling_participants(&current, &dummy, search_direction, true);
 560     if (search_result == false) {
 561         ysuccess(false);
 562         return false;
 563     }
 564
 565     /* get the default percentage */
 566     int children = con_num_children(current->parent);
 567     LOG("ins. %d children\n", children);
 568     double percentage = 1.0 / children;
 569     LOG("default percentage = %f\n", percentage);
 570
 571     /* Ensure all the other children have a percentage set. */
 572     Con *child;
 573     TAILQ_FOREACH(child, &(current->parent->nodes_head), nodes) {
 574         LOG("child->percent = %f (child %p)\n", child->percent, child);
 575         if (child->percent == 0.0)
 576             child->percent = percentage;
 577     }
 578
 579     double new_current_percent = current->percent + ((double)ppt / 100.0);
 580     double subtract_percent = ((double)ppt / 100.0) / (children - 1);
 581     LOG("new_current_percent = %f\n", new_current_percent);
 582     LOG("subtract_percent = %f\n", subtract_percent);
 583     /* Ensure that the new percentages are positive and greater than
 584      * 0.05 to have a reasonable minimum size. */
 585     TAILQ_FOREACH(child, &(current->parent->nodes_head), nodes) {
 586         if (child == current)
 587             continue;
 588         if (!definitelyGreaterThan(child->percent - subtract_percent, 0.05, DBL_EPSILON)) {
 589             LOG("Not resizing, already at minimum size (child %p would end up with a size of %.f\n", child, child->percent - subtract_percent);
 590             ysuccess(false);
 591             return false;
 592         }
 593     }
 594     if (!definitelyGreaterThan(new_current_percent, 0.05, DBL_EPSILON)) {
 595         LOG("Not resizing, already at minimum size\n");
 596         ysuccess(false);
 597         return false;
 598     }
 599
 600     current->percent += ((double)ppt / 100.0);
 601     LOG("current->percent after = %f\n", current->percent);
 602
 603     TAILQ_FOREACH(child, &(current->parent->nodes_head), nodes) {
 604         if (child == current)
 605             continue;
 606         child->percent -= subtract_percent;
 607         LOG("child->percent after (%p) = %f\n", child, child->percent);
 608     }
 609
 610     return true;
 611 }
 612
 613 /*
 614  * Implementation of 'resize grow|shrink <direction> [<px> px] [or <ppt> ppt]'.
 615  *
 616  */
 617 void cmd_resize(I3_CMD, const char *way, const char *direction, long resize_px, long resize_ppt) {
 618     DLOG("resizing in way %s, direction %s, px %ld or ppt %ld\n", way, direction, resize_px, resize_ppt);
 619     if (strcmp(way, "shrink") == 0) {
 620         resize_px *= -1;
 621         resize_ppt *= -1;
 622     }
 623
 624     HANDLE_EMPTY_MATCH;
 625
 626     owindow *current;
 627     TAILQ_FOREACH(current, &owindows, owindows) {
 628         /* Don't handle dock windows (issue #1201) */
 629         if (current->con->window && current->con->window->dock) {
 630             DLOG("This is a dock window. Not resizing (con = %p)\n)", current->con);
 631             continue;
 632         }
 633
 634         Con *floating_con;
 635         if ((floating_con = con_inside_floating(current->con))) {
 636             cmd_resize_floating(current_match, cmd_output, way, direction, floating_con, resize_px);
 637         } else {
 638             if (strcmp(direction, "width") == 0 ||
 639                 strcmp(direction, "height") == 0) {
 640                 if (!cmd_resize_tiling_width_height(current_match, cmd_output,
 641                                                     current->con, way, direction, resize_ppt))
 642                     return;
 643             } else {
 644                 if (!cmd_resize_tiling_direction(current_match, cmd_output,
 645                                                  current->con, way, direction, resize_ppt))
 646                     return;
 647             }
 648         }
 649     }
 650
 651     cmd_output->needs_tree_render = true;
 652     // XXX: default reply for now, make this a better reply
 653     ysuccess(true);
 654 }
 655
 656 /*
 657  * Implementation of 'resize set <width> [px | ppt] <height> [px | ppt]'.
 658  *
 659  */
 660 void cmd_resize_set(I3_CMD, long cwidth, const char *mode_width, long cheight, const char *mode_height) {
 661     DLOG("resizing to %ld %s x %ld %s\n", cwidth, mode_width, cheight, mode_height);
 662     if (cwidth < 0 || cheight < 0) {
 663         ELOG("Resize failed: dimensions cannot be negative (was %ld %s x %ld %s)\n", cwidth, mode_width, cheight, mode_height);
 664         return;
 665     }
 666
 667     HANDLE_EMPTY_MATCH;
 668
 669     owindow *current;
 670     bool success = true;
 671     TAILQ_FOREACH(current, &owindows, owindows) {
 672         Con *floating_con;
 673         if ((floating_con = con_inside_floating(current->con))) {
 674             Con *output = con_get_output(floating_con);
 675             if (cwidth == 0) {
 676                 cwidth = output->rect.width;
 677             } else if (mode_width && strcmp(mode_width, "ppt") == 0) {
 678                 cwidth = output->rect.width * ((double)cwidth / 100.0);
 679             }
 680             if (cheight == 0) {
 681                 cheight = output->rect.height;
 682             } else if (mode_height && strcmp(mode_height, "ppt") == 0) {
 683                 cheight = output->rect.height * ((double)cheight / 100.0);
 684             }
 685             floating_resize(floating_con, cwidth, cheight);
 686         } else {
 687             if (current->con->window && current->con->window->dock) {
 688                 DLOG("This is a dock window. Not resizing (con = %p)\n)", current->con);
 689                 continue;
 690             }
 691
 692             if (cwidth > 0 && mode_width && strcmp(mode_width, "ppt") == 0) {
 693                 /* get the appropriate current container (skip stacked/tabbed cons) */
 694                 Con *target = current->con;
 695                 Con *dummy;
 696                 resize_find_tiling_participants(&target, &dummy, D_LEFT, true);
 697
 698                 /* Calculate new size for the target container */
 699                 double current_percent = target->percent;
 700                 char *action_string;
 701                 long adjustment;
 702
 703                 if (current_percent > cwidth) {
 704                     action_string = "shrink";
 705                     adjustment = (int)(current_percent * 100) - cwidth;
 706                 } else {
 707                     action_string = "grow";
 708                     adjustment = cwidth - (int)(current_percent * 100);
 709                 }
 710
 711                 /* perform resizing and report failure if not possible */
 712                 if (!cmd_resize_tiling_width_height(current_match, cmd_output,
 713                                                     target, action_string, "width", adjustment)) {
 714                     success = false;
 715                 }
 716             }
 717
 718             if (cheight > 0 && mode_width && strcmp(mode_width, "ppt") == 0) {
 719                 /* get the appropriate current container (skip stacked/tabbed cons) */
 720                 Con *target = current->con;
 721                 Con *dummy;
 722                 resize_find_tiling_participants(&target, &dummy, D_DOWN, true);
 723
 724                 /* Calculate new size for the target container */
 725                 double current_percent = target->percent;
 726                 char *action_string;
 727                 long adjustment;
 728
 729                 if (current_percent > cheight) {
 730                     action_string = "shrink";
 731                     adjustment = (int)(current_percent * 100) - cheight;
 732                 } else {
 733                     action_string = "grow";
 734                     adjustment = cheight - (int)(current_percent * 100);
 735                 }
 736
 737                 /* perform resizing and report failure if not possible */
 738                 if (!cmd_resize_tiling_width_height(current_match, cmd_output,
 739                                                     target, action_string, "height", adjustment)) {
 740                     success = false;
 741                 }
 742             }
 743         }
 744     }
 745
 746     cmd_output->needs_tree_render = true;
 747     ysuccess(success);
 748 }
 749
 750 /*
 751  * Implementation of 'border normal|pixel [<n>]', 'border none|1pixel|toggle'.
 752  *
 753  */
 754 void cmd_border(I3_CMD, const char *border_style_str, long border_width) {
 755     DLOG("border style should be changed to %s with border width %ld\n", border_style_str, border_width);
 756     owindow *current;
 757
 758     HANDLE_EMPTY_MATCH;
 759
 760     TAILQ_FOREACH(current, &owindows, owindows) {
 761         DLOG("matching: %p / %s\n", current->con, current->con->name);
 762         int border_style = current->con->border_style;
 763         int con_border_width = border_width;
 764
 765         if (strcmp(border_style_str, "toggle") == 0) {
 766             border_style++;
 767             border_style %= 3;
 768             if (border_style == BS_NORMAL)
 769                 con_border_width = 2;
 770             else if (border_style == BS_NONE)
 771                 con_border_width = 0;
 772             else if (border_style == BS_PIXEL)
 773                 con_border_width = 1;
 774         } else {
 775             if (strcmp(border_style_str, "normal") == 0) {
 776                 border_style = BS_NORMAL;
 777             } else if (strcmp(border_style_str, "pixel") == 0) {
 778                 border_style = BS_PIXEL;
 779             } else if (strcmp(border_style_str, "1pixel") == 0) {
 780                 border_style = BS_PIXEL;
 781                 con_border_width = 1;
 782             } else if (strcmp(border_style_str, "none") == 0) {
 783                 border_style = BS_NONE;
 784             } else {
 785                 ELOG("BUG: called with border_style=%s\n", border_style_str);
 786                 ysuccess(false);
 787                 return;
 788             }
 789         }
 790
 791         con_set_border_style(current->con, border_style, logical_px(con_border_width));
 792     }
 793
 794     cmd_output->needs_tree_render = true;
 795     // XXX: default reply for now, make this a better reply
 796     ysuccess(true);
 797 }
 798
 799 /*
 800  * Implementation of 'nop <comment>'.
 801  *
 802  */
 803 void cmd_nop(I3_CMD, const char *comment) {
 804     LOG("-------------------------------------------------\n");
 805     LOG("  NOP: %s\n", comment);
 806     LOG("-------------------------------------------------\n");
 807     ysuccess(true);
 808 }
 809
 810 /*
 811  * Implementation of 'append_layout <path>'.
 812  *
 813  */
 814 void cmd_append_layout(I3_CMD, const char *cpath) {
 815     char *path = sstrdup(cpath);
 816     LOG("Appending layout \"%s\"\n", path);
 817
 818     /* Make sure we allow paths like '~/.i3/layout.json' */
 819     path = resolve_tilde(path);
 820
 821     char *buf = NULL;
 822     ssize_t len;
 823     if ((len = slurp(path, &buf)) < 0) {
 824         /* slurp already logged an error. */
 825         goto out;
 826     }
 827
 828     if (!json_validate(buf, len)) {
 829         ELOG("Could not parse \"%s\" as JSON, not loading.\n", path);
 830         yerror("Could not parse \"%s\" as JSON.", path);
 831         goto out;
 832     }
 833
 834     json_content_t content = json_determine_content(buf, len);
 835     LOG("JSON content = %d\n", content);
 836     if (content == JSON_CONTENT_UNKNOWN) {
 837         ELOG("Could not determine the contents of \"%s\", not loading.\n", path);
 838         yerror("Could not determine the contents of \"%s\".", path);
 839         goto out;
 840     }
 841
 842     Con *parent = focused;
 843     if (content == JSON_CONTENT_WORKSPACE) {
 844         parent = output_get_content(con_get_output(parent));
 845     } else {
 846         /* We need to append the layout to a split container, since a leaf
 847          * container must not have any children (by definition).
 848          * Note that we explicitly check for workspaces, since they are okay for
 849          * this purpose, but con_accepts_window() returns false for workspaces. */
 850         while (parent->type != CT_WORKSPACE && !con_accepts_window(parent))
 851             parent = parent->parent;
 852     }
 853     DLOG("Appending to parent=%p instead of focused=%p\n", parent, focused);
 854     char *errormsg = NULL;
 855     tree_append_json(parent, buf, len, &errormsg);
 856     if (errormsg != NULL) {
 857         yerror(errormsg);
 858         free(errormsg);
 859         /* Note that we continue executing since tree_append_json() has
 860          * side-effects — user-provided layouts can be partly valid, partly
 861          * invalid, leading to half of the placeholder containers being
 862          * created. */
 863     } else {
 864         ysuccess(true);
 865     }
 866
 867     // XXX: This is a bit of a kludge. Theoretically, render_con(parent,
 868     // false); should be enough, but when sending 'workspace 4; append_layout
 869     // /tmp/foo.json', the needs_tree_render == true of the workspace command
 870     // is not executed yet and will be batched with append_layout’s
 871     // needs_tree_render after the parser finished. We should check if that is
 872     // necessary at all.
 873     render_con(croot, false);
 874
 875     restore_open_placeholder_windows(parent);
 876
 877     if (content == JSON_CONTENT_WORKSPACE)
 878         ipc_send_workspace_event("restored", parent, NULL);
 879
 880     cmd_output->needs_tree_render = true;
 881 out:
 882     free(path);
 883     free(buf);
 884 }
 885
 886 /*
 887  * Implementation of 'workspace next|prev|next_on_output|prev_on_output'.
 888  *
 889  */
 890 void cmd_workspace(I3_CMD, const char *which) {
 891     Con *ws;
 892
 893     DLOG("which=%s\n", which);
 894
 895     if (con_get_fullscreen_con(croot, CF_GLOBAL)) {
 896         LOG("Cannot switch workspace while in global fullscreen\n");
 897         ysuccess(false);
 898         return;
 899     }
 900
 901     if (strcmp(which, "next") == 0)
 902         ws = workspace_next();
 903     else if (strcmp(which, "prev") == 0)
 904         ws = workspace_prev();
 905     else if (strcmp(which, "next_on_output") == 0)
 906         ws = workspace_next_on_output();
 907     else if (strcmp(which, "prev_on_output") == 0)
 908         ws = workspace_prev_on_output();
 909     else {
 910         ELOG("BUG: called with which=%s\n", which);
 911         ysuccess(false);
 912         return;
 913     }
 914
 915     workspace_show(ws);
 916
 917     cmd_output->needs_tree_render = true;
 918     // XXX: default reply for now, make this a better reply
 919     ysuccess(true);
 920 }
 921
 922 /*
 923  * Implementation of 'workspace [--no-auto-back-and-forth] number <name>'
 924  *
 925  */
 926 void cmd_workspace_number(I3_CMD, const char *which, const char *_no_auto_back_and_forth) {
 927     const bool no_auto_back_and_forth = (_no_auto_back_and_forth != NULL);
 928     Con *output, *workspace = NULL;
 929
 930     if (con_get_fullscreen_con(croot, CF_GLOBAL)) {
 931         LOG("Cannot switch workspace while in global fullscreen\n");
 932         ysuccess(false);
 933         return;
 934     }
 935
 936     long parsed_num = ws_name_to_number(which);
 937
 938     if (parsed_num == -1) {
 939         LOG("Could not parse initial part of \"%s\" as a number.\n", which);
 940         yerror("Could not parse number \"%s\"", which);
 941         return;
 942     }
 943
 944     TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
 945     GREP_FIRST(workspace, output_get_content(output),
 946                child->num == parsed_num);
 947
 948     if (!workspace) {
 949         LOG("There is no workspace with number %ld, creating a new one.\n", parsed_num);
 950         ysuccess(true);
 951         workspace_show_by_name(which);
 952         cmd_output->needs_tree_render = true;
 953         return;
 954     }
 955     if (!no_auto_back_and_forth && maybe_back_and_forth(cmd_output, workspace->name)) {
 956         ysuccess(true);
 957         return;
 958     }
 959     workspace_show(workspace);
 960
 961     cmd_output->needs_tree_render = true;
 962     // XXX: default reply for now, make this a better reply
 963     ysuccess(true);
 964 }
 965
 966 /*
 967  * Implementation of 'workspace back_and_forth'.
 968  *
 969  */
 970 void cmd_workspace_back_and_forth(I3_CMD) {
 971     if (con_get_fullscreen_con(croot, CF_GLOBAL)) {
 972         LOG("Cannot switch workspace while in global fullscreen\n");
 973         ysuccess(false);
 974         return;
 975     }
 976
 977     workspace_back_and_forth();
 978
 979     cmd_output->needs_tree_render = true;
 980     // XXX: default reply for now, make this a better reply
 981     ysuccess(true);
 982 }
 983
 984 /*
 985  * Implementation of 'workspace [--no-auto-back-and-forth] <name>'
 986  *
 987  */
 988 void cmd_workspace_name(I3_CMD, const char *name, const char *_no_auto_back_and_forth) {
 989     const bool no_auto_back_and_forth = (_no_auto_back_and_forth != NULL);
 990
 991     if (strncasecmp(name, "__", strlen("__")) == 0) {
 992         LOG("You cannot switch to the i3-internal workspaces (\"%s\").\n", name);
 993         ysuccess(false);
 994         return;
 995     }
 996
 997     if (con_get_fullscreen_con(croot, CF_GLOBAL)) {
 998         LOG("Cannot switch workspace while in global fullscreen\n");
 999         ysuccess(false);
1000         return;
1001     }
1002
1003     DLOG("should switch to workspace %s\n", name);
1004     if (!no_auto_back_and_forth && maybe_back_and_forth(cmd_output, name)) {
1005         ysuccess(true);
1006         return;
1007     }
1008     workspace_show_by_name(name);
1009
1010     cmd_output->needs_tree_render = true;
1011     // XXX: default reply for now, make this a better reply
1012     ysuccess(true);
1013 }
1014
1015 /*
1016  * Implementation of 'mark [--add|--replace] [--toggle] <mark>'
1017  *
1018  */
1019 void cmd_mark(I3_CMD, const char *mark, const char *mode, const char *toggle) {
1020     HANDLE_EMPTY_MATCH;
1021
1022     owindow *current = TAILQ_FIRST(&owindows);
1023     if (current == NULL) {
1024         ysuccess(false);
1025         return;
1026     }
1027
1028     /* Marks must be unique, i.e., no two windows must have the same mark. */
1029     if (current != TAILQ_LAST(&owindows, owindows_head)) {
1030         yerror("A mark must not be put onto more than one window");
1031         return;
1032     }
1033
1034     DLOG("matching: %p / %s\n", current->con, current->con->name);
1035
1036     mark_mode_t mark_mode = (mode == NULL || strcmp(mode, "--replace") == 0) ? MM_REPLACE : MM_ADD;
1037     if (toggle != NULL) {
1038         con_mark_toggle(current->con, mark, mark_mode);
1039     } else {
1040         con_mark(current->con, mark, mark_mode);
1041     }
1042
1043     cmd_output->needs_tree_render = true;
1044     // XXX: default reply for now, make this a better reply
1045     ysuccess(true);
1046 }
1047
1048 /*
1049  * Implementation of 'unmark [mark]'
1050  *
1051  */
1052 void cmd_unmark(I3_CMD, const char *mark) {
1053     if (match_is_empty(current_match)) {
1054         con_unmark(NULL, mark);
1055     } else {
1056         owindow *current;
1057         TAILQ_FOREACH(current, &owindows, owindows) {
1058             con_unmark(current->con, mark);
1059         }
1060     }
1061
1062     cmd_output->needs_tree_render = true;
1063     // XXX: default reply for now, make this a better reply
1064     ysuccess(true);
1065 }
1066
1067 /*
1068  * Implementation of 'mode <string>'.
1069  *
1070  */
1071 void cmd_mode(I3_CMD, const char *mode) {
1072     DLOG("mode=%s\n", mode);
1073     switch_mode(mode);
1074
1075     // XXX: default reply for now, make this a better reply
1076     ysuccess(true);
1077 }
1078
1079 /*
1080  * Implementation of 'move [window|container] [to] output <str>'.
1081  *
1082  */
1083 void cmd_move_con_to_output(I3_CMD, const char *name) {
1084     DLOG("Should move window to output \"%s\".\n", name);
1085     HANDLE_EMPTY_MATCH;
1086
1087     owindow *current;
1088     bool had_error = false;
1089     TAILQ_FOREACH(current, &owindows, owindows) {
1090         DLOG("matching: %p / %s\n", current->con, current->con->name);
1091
1092         had_error |= !con_move_to_output_name(current->con, name, true);
1093     }
1094
1095     cmd_output->needs_tree_render = true;
1096     ysuccess(!had_error);
1097 }
1098
1099 /*
1100  * Implementation of 'move [container|window] [to] mark <str>'.
1101  *
1102  */
1103 void cmd_move_con_to_mark(I3_CMD, const char *mark) {
1104     DLOG("moving window to mark \"%s\"\n", mark);
1105
1106     HANDLE_EMPTY_MATCH;
1107
1108     bool result = true;
1109     owindow *current;
1110     TAILQ_FOREACH(current, &owindows, owindows) {
1111         DLOG("moving matched window %p / %s to mark \"%s\"\n", current->con, current->con->name, mark);
1112         result &= con_move_to_mark(current->con, mark);
1113     }
1114
1115     cmd_output->needs_tree_render = true;
1116     ysuccess(result);
1117 }
1118
1119 /*
1120  * Implementation of 'floating enable|disable|toggle'
1121  *
1122  */
1123 void cmd_floating(I3_CMD, const char *floating_mode) {
1124     owindow *current;
1125
1126     DLOG("floating_mode=%s\n", floating_mode);
1127
1128     HANDLE_EMPTY_MATCH;
1129
1130     TAILQ_FOREACH(current, &owindows, owindows) {
1131         DLOG("matching: %p / %s\n", current->con, current->con->name);
1132         if (strcmp(floating_mode, "toggle") == 0) {
1133             DLOG("should toggle mode\n");
1134             toggle_floating_mode(current->con, false);
1135         } else {
1136             DLOG("should switch mode to %s\n", floating_mode);
1137             if (strcmp(floating_mode, "enable") == 0) {
1138                 floating_enable(current->con, false);
1139             } else {
1140                 floating_disable(current->con, false);
1141             }
1142         }
1143     }
1144
1145     cmd_output->needs_tree_render = true;
1146     // XXX: default reply for now, make this a better reply
1147     ysuccess(true);
1148 }
1149
1150 /*
1151  * Implementation of 'move workspace to [output] <str>'.
1152  *
1153  */
1154 void cmd_move_workspace_to_output(I3_CMD, const char *name) {
1155     DLOG("should move workspace to output %s\n", name);
1156
1157     HANDLE_EMPTY_MATCH;
1158
1159     owindow *current;
1160     TAILQ_FOREACH(current, &owindows, owindows) {
1161         Con *ws = con_get_workspace(current->con);
1162         if (con_is_internal(ws)) {
1163             continue;
1164         }
1165
1166         bool success = workspace_move_to_output(ws, name);
1167         if (!success) {
1168             ELOG("Failed to move workspace to output.\n");
1169             ysuccess(false);
1170             return;
1171         }
1172     }
1173
1174     cmd_output->needs_tree_render = true;
1175     // XXX: default reply for now, make this a better reply
1176     ysuccess(true);
1177 }
1178
1179 /*
1180  * Implementation of 'split v|h|t|vertical|horizontal|toggle'.
1181  *
1182  */
1183 void cmd_split(I3_CMD, const char *direction) {
1184     HANDLE_EMPTY_MATCH;
1185
1186     owindow *current;
1187     LOG("splitting in direction %c\n", direction[0]);
1188     TAILQ_FOREACH(current, &owindows, owindows) {
1189         if (con_is_docked(current->con)) {
1190             ELOG("Cannot split a docked container, skipping.\n");
1191             continue;
1192         }
1193
1194         DLOG("matching: %p / %s\n", current->con, current->con->name);
1195         if (direction[0] == 't') {
1196             layout_t current_layout;
1197             if (current->con->type == CT_WORKSPACE) {
1198                 current_layout = current->con->layout;
1199             } else {
1200                 current_layout = current->con->parent->layout;
1201             }
1202             /* toggling split orientation */
1203             if (current_layout == L_SPLITH) {
1204                 tree_split(current->con, VERT);
1205             } else {
1206                 tree_split(current->con, HORIZ);
1207             }
1208         } else {
1209             tree_split(current->con, (direction[0] == 'v' ? VERT : HORIZ));
1210         }
1211     }
1212
1213     cmd_output->needs_tree_render = true;
1214     // XXX: default reply for now, make this a better reply
1215     ysuccess(true);
1216 }
1217
1218 /*
1219  * Implementation of 'kill [window|client]'.
1220  *
1221  */
1222 void cmd_kill(I3_CMD, const char *kill_mode_str) {
1223     if (kill_mode_str == NULL)
1224         kill_mode_str = "window";
1225
1226     DLOG("kill_mode=%s\n", kill_mode_str);
1227
1228     int kill_mode;
1229     if (strcmp(kill_mode_str, "window") == 0)
1230         kill_mode = KILL_WINDOW;
1231     else if (strcmp(kill_mode_str, "client") == 0)
1232         kill_mode = KILL_CLIENT;
1233     else {
1234         ELOG("BUG: called with kill_mode=%s\n", kill_mode_str);
1235         ysuccess(false);
1236         return;
1237     }
1238
1239     HANDLE_EMPTY_MATCH;
1240
1241     owindow *current;
1242     TAILQ_FOREACH(current, &owindows, owindows) {
1243         con_close(current->con, kill_mode);
1244     }
1245
1246     cmd_output->needs_tree_render = true;
1247     // XXX: default reply for now, make this a better reply
1248     ysuccess(true);
1249 }
1250
1251 /*
1252  * Implementation of 'exec [--no-startup-id] <command>'.
1253  *
1254  */
1255 void cmd_exec(I3_CMD, const char *nosn, const char *command) {
1256     bool no_startup_id = (nosn != NULL);
1257
1258     DLOG("should execute %s, no_startup_id = %d\n", command, no_startup_id);
1259     start_application(command, no_startup_id);
1260
1261     // XXX: default reply for now, make this a better reply
1262     ysuccess(true);
1263 }
1264
1265 /*
1266  * Implementation of 'focus left|right|up|down'.
1267  *
1268  */
1269 void cmd_focus_direction(I3_CMD, const char *direction) {
1270     DLOG("direction = *%s*\n", direction);
1271
1272     if (strcmp(direction, "left") == 0)
1273         tree_next('p', HORIZ);
1274     else if (strcmp(direction, "right") == 0)
1275         tree_next('n', HORIZ);
1276     else if (strcmp(direction, "up") == 0)
1277         tree_next('p', VERT);
1278     else if (strcmp(direction, "down") == 0)
1279         tree_next('n', VERT);
1280     else {
1281         ELOG("Invalid focus direction (%s)\n", direction);
1282         ysuccess(false);
1283         return;
1284     }
1285
1286     cmd_output->needs_tree_render = true;
1287     // XXX: default reply for now, make this a better reply
1288     ysuccess(true);
1289 }
1290
1291 /*
1292  * Focus a container and disable any other fullscreen container not permitting the focus.
1293  *
1294  */
1295 static void cmd_focus_force_focus(Con *con) {
1296     /* Disable fullscreen container in workspace with container to be focused. */
1297     Con *ws = con_get_workspace(con);
1298     Con *fullscreen_on_ws = (focused && focused->fullscreen_mode == CF_GLOBAL) ? focused : con_get_fullscreen_con(ws, CF_OUTPUT);
1299     if (fullscreen_on_ws && fullscreen_on_ws != con && !con_has_parent(con, fullscreen_on_ws)) {
1300         con_disable_fullscreen(fullscreen_on_ws);
1301     }
1302     con_focus(con);
1303 }
1304
1305 /*
1306  * Implementation of 'focus tiling|floating|mode_toggle'.
1307  *
1308  */
1309 void cmd_focus_window_mode(I3_CMD, const char *window_mode) {
1310     DLOG("window_mode = %s\n", window_mode);
1311
1312     bool to_floating = false;
1313     if (strcmp(window_mode, "mode_toggle") == 0) {
1314         to_floating = !con_inside_floating(focused);
1315     } else if (strcmp(window_mode, "floating") == 0) {
1316         to_floating = true;
1317     } else if (strcmp(window_mode, "tiling") == 0) {
1318         to_floating = false;
1319     }
1320
1321     Con *ws = con_get_workspace(focused);
1322     Con *current;
1323     bool success = false;
1324     TAILQ_FOREACH(current, &(ws->focus_head), focused) {
1325         if ((to_floating && current->type != CT_FLOATING_CON) ||
1326             (!to_floating && current->type == CT_FLOATING_CON))
1327             continue;
1328
1329         cmd_focus_force_focus(con_descend_focused(current));
1330         success = true;
1331         break;
1332     }
1333
1334     if (success) {
1335         cmd_output->needs_tree_render = true;
1336         ysuccess(true);
1337     } else {
1338         yerror("Failed to find a %s container in workspace.", to_floating ? "floating" : "tiling");
1339     }
1340 }
1341
1342 /*
1343  * Implementation of 'focus parent|child'.
1344  *
1345  */
1346 void cmd_focus_level(I3_CMD, const char *level) {
1347     DLOG("level = %s\n", level);
1348     bool success = false;
1349
1350     /* Focusing the parent can only be allowed if the newly
1351      * focused container won't escape the fullscreen container. */
1352     if (strcmp(level, "parent") == 0) {
1353         if (focused && focused->parent) {
1354             if (con_fullscreen_permits_focusing(focused->parent))
1355                 success = level_up();
1356             else
1357                 ELOG("'focus parent': Currently in fullscreen, not going up\n");
1358         }
1359     }
1360
1361     /* Focusing a child should always be allowed. */
1362     else
1363         success = level_down();
1364
1365     cmd_output->needs_tree_render = success;
1366     // XXX: default reply for now, make this a better reply
1367     ysuccess(success);
1368 }
1369
1370 /*
1371  * Implementation of 'focus'.
1372  *
1373  */
1374 void cmd_focus(I3_CMD) {
1375     DLOG("current_match = %p\n", current_match);
1376
1377     if (match_is_empty(current_match)) {
1378         ELOG("You have to specify which window/container should be focused.\n");
1379         ELOG("Example: [class=\"urxvt\" title=\"irssi\"] focus\n");
1380
1381         yerror("You have to specify which window/container should be focused");
1382
1383         return;
1384     }
1385
1386     Con *__i3_scratch = workspace_get("__i3_scratch", NULL);
1387     int count = 0;
1388     owindow *current;
1389     TAILQ_FOREACH(current, &owindows, owindows) {
1390         Con *ws = con_get_workspace(current->con);
1391         /* If no workspace could be found, this was a dock window.
1392          * Just skip it, you cannot focus dock windows. */
1393         if (!ws)
1394             continue;
1395
1396         /* In case this is a scratchpad window, call scratchpad_show(). */
1397         if (ws == __i3_scratch) {
1398             scratchpad_show(current->con);
1399             count++;
1400             /* While for the normal focus case we can change focus multiple
1401              * times and only a single window ends up focused, we could show
1402              * multiple scratchpad windows. So, rather break here. */
1403             break;
1404         }
1405
1406         /* If the container is not on the current workspace,
1407          * workspace_show() will switch to a different workspace and (if
1408          * enabled) trigger a mouse pointer warp to the currently focused
1409          * container (!) on the target workspace.
1410          *
1411          * Therefore, before calling workspace_show(), we make sure that
1412          * 'current' will be focused on the workspace. However, we cannot
1413          * just con_focus(current) because then the pointer will not be
1414          * warped at all (the code thinks we are already there).
1415          *
1416          * So we focus 'current' to make it the currently focused window of
1417          * the target workspace, then revert focus. */
1418         Con *currently_focused = focused;
1419         cmd_focus_force_focus(current->con);
1420         con_focus(currently_focused);
1421
1422         /* Now switch to the workspace, then focus */
1423         workspace_show(ws);
1424         LOG("focusing %p / %s\n", current->con, current->con->name);
1425         con_focus(current->con);
1426         count++;
1427     }
1428
1429     if (count > 1)
1430         LOG("WARNING: Your criteria for the focus command matches %d containers, "
1431             "while only exactly one container can be focused at a time.\n",
1432             count);
1433
1434     cmd_output->needs_tree_render = true;
1435     ysuccess(count > 0);
1436 }
1437
1438 /*
1439  * Implementation of 'fullscreen enable|toggle [global]' and
1440  *                   'fullscreen disable'
1441  *
1442  */
1443 void cmd_fullscreen(I3_CMD, const char *action, const char *fullscreen_mode) {
1444     fullscreen_mode_t mode = strcmp(fullscreen_mode, "global") == 0 ? CF_GLOBAL : CF_OUTPUT;
1445     DLOG("%s fullscreen, mode = %s\n", action, fullscreen_mode);
1446     owindow *current;
1447
1448     HANDLE_EMPTY_MATCH;
1449
1450     TAILQ_FOREACH(current, &owindows, owindows) {
1451         DLOG("matching: %p / %s\n", current->con, current->con->name);
1452         if (strcmp(action, "toggle") == 0) {
1453             con_toggle_fullscreen(current->con, mode);
1454         } else if (strcmp(action, "enable") == 0) {
1455             con_enable_fullscreen(current->con, mode);
1456         } else if (strcmp(action, "disable") == 0) {
1457             con_disable_fullscreen(current->con);
1458         }
1459     }
1460
1461     cmd_output->needs_tree_render = true;
1462     // XXX: default reply for now, make this a better reply
1463     ysuccess(true);
1464 }
1465
1466 /*
1467  * Implementation of 'sticky enable|disable|toggle'.
1468  *
1469  */
1470 void cmd_sticky(I3_CMD, const char *action) {
1471     DLOG("%s sticky on window\n", action);
1472     HANDLE_EMPTY_MATCH;
1473
1474     owindow *current;
1475     TAILQ_FOREACH(current, &owindows, owindows) {
1476         if (current->con->window == NULL) {
1477             ELOG("only containers holding a window can be made sticky, skipping con = %p\n", current->con);
1478             continue;
1479         }
1480         DLOG("setting sticky for container = %p / %s\n", current->con, current->con->name);
1481
1482         bool sticky = false;
1483         if (strcmp(action, "enable") == 0)
1484             sticky = true;
1485         else if (strcmp(action, "disable") == 0)
1486             sticky = false;
1487         else if (strcmp(action, "toggle") == 0)
1488             sticky = !current->con->sticky;
1489
1490         current->con->sticky = sticky;
1491         ewmh_update_sticky(current->con->window->id, sticky);
1492     }
1493
1494     /* A window we made sticky might not be on a visible workspace right now, so we need to make
1495      * sure it gets pushed to the front now. */
1496     output_push_sticky_windows(focused);
1497
1498     ewmh_update_wm_desktop();
1499
1500     cmd_output->needs_tree_render = true;
1501     ysuccess(true);
1502 }
1503
1504 /*
1505  * Implementation of 'move <direction> [<pixels> [px]]'.
1506  *
1507  */
1508 void cmd_move_direction(I3_CMD, const char *direction, long move_px) {
1509     owindow *current;
1510     HANDLE_EMPTY_MATCH;
1511
1512     Con *initially_focused = focused;
1513
1514     TAILQ_FOREACH(current, &owindows, owindows) {
1515         DLOG("moving in direction %s, px %ld\n", direction, move_px);
1516         if (con_is_floating(current->con)) {
1517             DLOG("floating move with %ld pixels\n", move_px);
1518             Rect newrect = current->con->parent->rect;
1519             if (strcmp(direction, "left") == 0) {
1520                 newrect.x -= move_px;
1521             } else if (strcmp(direction, "right") == 0) {
1522                 newrect.x += move_px;
1523             } else if (strcmp(direction, "up") == 0) {
1524                 newrect.y -= move_px;
1525             } else if (strcmp(direction, "down") == 0) {
1526                 newrect.y += move_px;
1527             }
1528             floating_reposition(current->con->parent, newrect);
1529         } else {
1530             tree_move(current->con, (strcmp(direction, "right") == 0 ? D_RIGHT : (strcmp(direction, "left") == 0 ? D_LEFT : (strcmp(direction, "up") == 0 ? D_UP : D_DOWN))));
1531             cmd_output->needs_tree_render = true;
1532         }
1533     }
1534
1535     /* the move command should not disturb focus */
1536     if (focused != initially_focused)
1537         con_focus(initially_focused);
1538
1539     // XXX: default reply for now, make this a better reply
1540     ysuccess(true);
1541 }
1542
1543 /*
1544  * Implementation of 'layout default|stacked|stacking|tabbed|splitv|splith'.
1545  *
1546  */
1547 void cmd_layout(I3_CMD, const char *layout_str) {
1548     HANDLE_EMPTY_MATCH;
1549
1550     layout_t layout;
1551     if (!layout_from_name(layout_str, &layout)) {
1552         ELOG("Unknown layout \"%s\", this is a mismatch between code and parser spec.\n", layout_str);
1553         return;
1554     }
1555
1556     DLOG("changing layout to %s (%d)\n", layout_str, layout);
1557
1558     owindow *current;
1559     TAILQ_FOREACH(current, &owindows, owindows) {
1560         if (con_is_docked(current->con)) {
1561             ELOG("cannot change layout of a docked container, skipping it.\n");
1562             continue;
1563         }
1564
1565         DLOG("matching: %p / %s\n", current->con, current->con->name);
1566         con_set_layout(current->con, layout);
1567     }
1568
1569     cmd_output->needs_tree_render = true;
1570     // XXX: default reply for now, make this a better reply
1571     ysuccess(true);
1572 }
1573
1574 /*
1575  * Implementation of 'layout toggle [all|split]'.
1576  *
1577  */
1578 void cmd_layout_toggle(I3_CMD, const char *toggle_mode) {
1579     owindow *current;
1580
1581     if (toggle_mode == NULL)
1582         toggle_mode = "default";
1583
1584     DLOG("toggling layout (mode = %s)\n", toggle_mode);
1585
1586     /* check if the match is empty, not if the result is empty */
1587     if (match_is_empty(current_match))
1588         con_toggle_layout(focused, toggle_mode);
1589     else {
1590         TAILQ_FOREACH(current, &owindows, owindows) {
1591             DLOG("matching: %p / %s\n", current->con, current->con->name);
1592             con_toggle_layout(current->con, toggle_mode);
1593         }
1594     }
1595
1596     cmd_output->needs_tree_render = true;
1597     // XXX: default reply for now, make this a better reply
1598     ysuccess(true);
1599 }
1600
1601 /*
1602  * Implementation of 'exit'.
1603  *
1604  */
1605 void cmd_exit(I3_CMD) {
1606     LOG("Exiting due to user command.\n");
1607 #ifdef I3_ASAN_ENABLED
1608     __lsan_do_leak_check();
1609 #endif
1610     ipc_shutdown(SHUTDOWN_REASON_EXIT);
1611     unlink(config.ipc_socket_path);
1612     xcb_disconnect(conn);
1613     exit(0);
1614
1615     /* unreached */
1616 }
1617
1618 /*
1619  * Implementation of 'reload'.
1620  *
1621  */
1622 void cmd_reload(I3_CMD) {
1623     LOG("reloading\n");
1624     kill_nagbar(&config_error_nagbar_pid, false);
1625     kill_nagbar(&command_error_nagbar_pid, false);
1626     load_configuration(conn, NULL, true);
1627     x_set_i3_atoms();
1628     /* Send an IPC event just in case the ws names have changed */
1629     ipc_send_workspace_event("reload", NULL, NULL);
1630     /* Send an update event for the barconfig just in case it has changed */
1631     update_barconfig();
1632
1633     // XXX: default reply for now, make this a better reply
1634     ysuccess(true);
1635 }
1636
1637 /*
1638  * Implementation of 'restart'.
1639  *
1640  */
1641 void cmd_restart(I3_CMD) {
1642     LOG("restarting i3\n");
1643     ipc_shutdown(SHUTDOWN_REASON_RESTART);
1644     unlink(config.ipc_socket_path);
1645     /* We need to call this manually since atexit handlers don’t get called
1646      * when exec()ing */
1647     purge_zerobyte_logfile();
1648     i3_restart(false);
1649
1650     // XXX: default reply for now, make this a better reply
1651     ysuccess(true);
1652 }
1653
1654 /*
1655  * Implementation of 'open'.
1656  *
1657  */
1658 void cmd_open(I3_CMD) {
1659     LOG("opening new container\n");
1660     Con *con = tree_open_con(NULL, NULL);
1661     con->layout = L_SPLITH;
1662     con_focus(con);
1663
1664     y(map_open);
1665     ystr("success");
1666     y(bool, true);
1667     ystr("id");
1668     y(integer, (uintptr_t)con);
1669     y(map_close);
1670
1671     cmd_output->needs_tree_render = true;
1672 }
1673
1674 /*
1675  * Implementation of 'focus output <output>'.
1676  *
1677  */
1678 void cmd_focus_output(I3_CMD, const char *name) {
1679     owindow *current;
1680
1681     DLOG("name = %s\n", name);
1682
1683     HANDLE_EMPTY_MATCH;
1684
1685     /* get the output */
1686     Output *current_output = NULL;
1687     Output *output;
1688
1689     TAILQ_FOREACH(current, &owindows, owindows)
1690     current_output = get_output_for_con(current->con);
1691     assert(current_output != NULL);
1692
1693     output = get_output_from_string(current_output, name);
1694
1695     if (!output) {
1696         LOG("No such output found.\n");
1697         ysuccess(false);
1698         return;
1699     }
1700
1701     /* get visible workspace on output */
1702     Con *ws = NULL;
1703     GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
1704     if (!ws) {
1705         ysuccess(false);
1706         return;
1707     }
1708
1709     workspace_show(ws);
1710
1711     cmd_output->needs_tree_render = true;
1712     // XXX: default reply for now, make this a better reply
1713     ysuccess(true);
1714 }
1715
1716 /*
1717  * Implementation of 'move [window|container] [to] [absolute] position <px> [px] <px> [px]
1718  *
1719  */
1720 void cmd_move_window_to_position(I3_CMD, const char *method, long x, long y) {
1721     bool has_error = false;
1722
1723     owindow *current;
1724     HANDLE_EMPTY_MATCH;
1725
1726     TAILQ_FOREACH(current, &owindows, owindows) {
1727         if (!con_is_floating(current->con)) {
1728             ELOG("Cannot change position. The window/container is not floating\n");
1729
1730             if (!has_error) {
1731                 yerror("Cannot change position of a window/container because it is not floating.");
1732                 has_error = true;
1733             }
1734
1735             continue;
1736         }
1737
1738         if (strcmp(method, "absolute") == 0) {
1739             current->con->parent->rect.x = x;
1740             current->con->parent->rect.y = y;
1741
1742             DLOG("moving to absolute position %ld %ld\n", x, y);
1743             floating_maybe_reassign_ws(current->con->parent);
1744             cmd_output->needs_tree_render = true;
1745         }
1746
1747         if (strcmp(method, "position") == 0) {
1748             Rect newrect = current->con->parent->rect;
1749
1750             DLOG("moving to position %ld %ld\n", x, y);
1751             newrect.x = x;
1752             newrect.y = y;
1753
1754             floating_reposition(current->con->parent, newrect);
1755         }
1756     }
1757
1758     // XXX: default reply for now, make this a better reply
1759     if (!has_error)
1760         ysuccess(true);
1761 }
1762
1763 /*
1764  * Implementation of 'move [window|container] [to] [absolute] position center
1765  *
1766  */
1767 void cmd_move_window_to_center(I3_CMD, const char *method) {
1768     bool has_error = false;
1769     HANDLE_EMPTY_MATCH;
1770
1771     owindow *current;
1772     TAILQ_FOREACH(current, &owindows, owindows) {
1773         Con *floating_con = con_inside_floating(current->con);
1774         if (floating_con == NULL) {
1775             ELOG("con %p / %s is not floating, cannot move it to the center.\n",
1776                  current->con, current->con->name);
1777
1778             if (!has_error) {
1779                 yerror("Cannot change position of a window/container because it is not floating.");
1780                 has_error = true;
1781             }
1782
1783             continue;
1784         }
1785
1786         if (strcmp(method, "absolute") == 0) {
1787             DLOG("moving to absolute center\n");
1788             floating_center(floating_con, croot->rect);
1789
1790             floating_maybe_reassign_ws(floating_con);
1791             cmd_output->needs_tree_render = true;
1792         }
1793
1794         if (strcmp(method, "position") == 0) {
1795             DLOG("moving to center\n");
1796             floating_center(floating_con, con_get_workspace(floating_con)->rect);
1797
1798             cmd_output->needs_tree_render = true;
1799         }
1800     }
1801
1802     // XXX: default reply for now, make this a better reply
1803     if (!has_error)
1804         ysuccess(true);
1805 }
1806
1807 /*
1808  * Implementation of 'move [window|container] [to] position mouse'
1809  *
1810  */
1811 void cmd_move_window_to_mouse(I3_CMD) {
1812     HANDLE_EMPTY_MATCH;
1813
1814     owindow *current;
1815     TAILQ_FOREACH(current, &owindows, owindows) {
1816         Con *floating_con = con_inside_floating(current->con);
1817         if (floating_con == NULL) {
1818             DLOG("con %p / %s is not floating, cannot move it to the mouse position.\n",
1819                  current->con, current->con->name);
1820             continue;
1821         }
1822
1823         DLOG("moving floating container %p / %s to cursor position\n", floating_con, floating_con->name);
1824         floating_move_to_pointer(floating_con);
1825     }
1826
1827     cmd_output->needs_tree_render = true;
1828     ysuccess(true);
1829 }
1830
1831 /*
1832  * Implementation of 'move scratchpad'.
1833  *
1834  */
1835 void cmd_move_scratchpad(I3_CMD) {
1836     DLOG("should move window to scratchpad\n");
1837     owindow *current;
1838
1839     HANDLE_EMPTY_MATCH;
1840
1841     TAILQ_FOREACH(current, &owindows, owindows) {
1842         DLOG("matching: %p / %s\n", current->con, current->con->name);
1843         scratchpad_move(current->con);
1844     }
1845
1846     cmd_output->needs_tree_render = true;
1847     // XXX: default reply for now, make this a better reply
1848     ysuccess(true);
1849 }
1850
1851 /*
1852  * Implementation of 'scratchpad show'.
1853  *
1854  */
1855 void cmd_scratchpad_show(I3_CMD) {
1856     DLOG("should show scratchpad window\n");
1857     owindow *current;
1858
1859     if (match_is_empty(current_match)) {
1860         scratchpad_show(NULL);
1861     } else {
1862         TAILQ_FOREACH(current, &owindows, owindows) {
1863             DLOG("matching: %p / %s\n", current->con, current->con->name);
1864             scratchpad_show(current->con);
1865         }
1866     }
1867
1868     cmd_output->needs_tree_render = true;
1869     // XXX: default reply for now, make this a better reply
1870     ysuccess(true);
1871 }
1872
1873 /*
1874  * Implementation of 'swap [container] [with] id|con_id|mark <arg>'.
1875  *
1876  */
1877 void cmd_swap(I3_CMD, const char *mode, const char *arg) {
1878     HANDLE_EMPTY_MATCH;
1879
1880     owindow *match = TAILQ_FIRST(&owindows);
1881     if (match == NULL) {
1882         DLOG("No match found for swapping.\n");
1883         return;
1884     }
1885
1886     Con *con;
1887     if (strcmp(mode, "id") == 0) {
1888         long target;
1889         if (!parse_long(arg, &target, 0)) {
1890             yerror("Failed to parse %s into a window id.\n", arg);
1891             return;
1892         }
1893
1894         con = con_by_window_id(target);
1895     } else if (strcmp(mode, "con_id") == 0) {
1896         long target;
1897         if (!parse_long(arg, &target, 0)) {
1898             yerror("Failed to parse %s into a container id.\n", arg);
1899             return;
1900         }
1901
1902         con = con_by_con_id(target);
1903     } else if (strcmp(mode, "mark") == 0) {
1904         con = con_by_mark(arg);
1905     } else {
1906         yerror("Unhandled swap mode \"%s\". This is a bug.\n", mode);
1907         return;
1908     }
1909
1910     if (con == NULL) {
1911         yerror("Could not find container for %s = %s\n", mode, arg);
1912         return;
1913     }
1914
1915     if (match != TAILQ_LAST(&owindows, owindows_head)) {
1916         DLOG("More than one container matched the swap command, only using the first one.");
1917     }
1918
1919     if (match->con == NULL) {
1920         DLOG("Match %p has no container.\n", match);
1921         ysuccess(false);
1922         return;
1923     }
1924
1925     DLOG("Swapping %p with %p.\n", match->con, con);
1926     bool result = con_swap(match->con, con);
1927
1928     cmd_output->needs_tree_render = true;
1929     ysuccess(result);
1930 }
1931
1932 /*
1933  * Implementation of 'title_format <format>'
1934  *
1935  */
1936 void cmd_title_format(I3_CMD, const char *format) {
1937     DLOG("setting title_format to \"%s\"\n", format);
1938     HANDLE_EMPTY_MATCH;
1939
1940     owindow *current;
1941     TAILQ_FOREACH(current, &owindows, owindows) {
1942         DLOG("setting title_format for %p / %s\n", current->con, current->con->name);
1943         FREE(current->con->title_format);
1944
1945         /* If we only display the title without anything else, we can skip the parsing step,
1946          * so we remove the title format altogether. */
1947         if (strcasecmp(format, "%title") != 0) {
1948             current->con->title_format = sstrdup(format);
1949
1950             if (current->con->window != NULL) {
1951                 i3String *formatted_title = con_parse_title_format(current->con);
1952                 ewmh_update_visible_name(current->con->window->id, i3string_as_utf8(formatted_title));
1953                 I3STRING_FREE(formatted_title);
1954             }
1955         } else {
1956             if (current->con->window != NULL) {
1957                 /* We can remove _NET_WM_VISIBLE_NAME since we don't display a custom title. */
1958                 ewmh_update_visible_name(current->con->window->id, NULL);
1959             }
1960         }
1961
1962         if (current->con->window != NULL) {
1963             /* Make sure the window title is redrawn immediately. */
1964             current->con->window->name_x_changed = true;
1965         } else {
1966             /* For windowless containers we also need to force the redrawing. */
1967             FREE(current->con->deco_render_params);
1968         }
1969     }
1970
1971     cmd_output->needs_tree_render = true;
1972     ysuccess(true);
1973 }
1974
1975 /*
1976  * Implementation of 'rename workspace [<name>] to <name>'
1977  *
1978  */
1979 void cmd_rename_workspace(I3_CMD, const char *old_name, const char *new_name) {
1980     if (strncasecmp(new_name, "__", strlen("__")) == 0) {
1981         LOG("Cannot rename workspace to \"%s\": names starting with __ are i3-internal.\n", new_name);
1982         ysuccess(false);
1983         return;
1984     }
1985     if (old_name) {
1986         LOG("Renaming workspace \"%s\" to \"%s\"\n", old_name, new_name);
1987     } else {
1988         LOG("Renaming current workspace to \"%s\"\n", new_name);
1989     }
1990
1991     Con *output, *workspace = NULL;
1992     if (old_name) {
1993         TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
1994         GREP_FIRST(workspace, output_get_content(output),
1995                    !strcasecmp(child->name, old_name));
1996     } else {
1997         workspace = con_get_workspace(focused);
1998         old_name = workspace->name;
1999     }
2000
2001     if (!workspace) {
2002         yerror("Old workspace \"%s\" not found", old_name);
2003         return;
2004     }
2005
2006     Con *check_dest = NULL;
2007     TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
2008     GREP_FIRST(check_dest, output_get_content(output),
2009                !strcasecmp(child->name, new_name));
2010
2011     /* If check_dest == workspace, the user might be changing the case of the
2012      * workspace, or it might just be a no-op. */
2013     if (check_dest != NULL && check_dest != workspace) {
2014         yerror("New workspace \"%s\" already exists", new_name);
2015         return;
2016     }
2017
2018     /* Change the name and try to parse it as a number. */
2019     /* old_name might refer to workspace->name, so copy it before free()ing */
2020     char *old_name_copy = sstrdup(old_name);
2021     FREE(workspace->name);
2022     workspace->name = sstrdup(new_name);
2023
2024     workspace->num = ws_name_to_number(new_name);
2025     LOG("num = %d\n", workspace->num);
2026
2027     /* By re-attaching, the sort order will be correct afterwards. */
2028     Con *previously_focused = focused;
2029     Con *parent = workspace->parent;
2030     con_detach(workspace);
2031     con_attach(workspace, parent, false);
2032
2033     /* Move the workspace to the correct output if it has an assignment */
2034     struct Workspace_Assignment *assignment = NULL;
2035     TAILQ_FOREACH(assignment, &ws_assignments, ws_assignments) {
2036         if (assignment->output == NULL)
2037             continue;
2038         if (strcmp(assignment->name, workspace->name) != 0 && (!name_is_digits(assignment->name) || ws_name_to_number(assignment->name) != workspace->num)) {
2039             continue;
2040         }
2041
2042         workspace_move_to_output(workspace, assignment->output);
2043
2044         if (previously_focused)
2045             workspace_show(con_get_workspace(previously_focused));
2046
2047         break;
2048     }
2049
2050     /* Restore the previous focus since con_attach messes with the focus. */
2051     con_focus(previously_focused);
2052
2053     cmd_output->needs_tree_render = true;
2054     ysuccess(true);
2055
2056     ipc_send_workspace_event("rename", workspace, NULL);
2057     ewmh_update_desktop_names();
2058     ewmh_update_desktop_viewport();
2059     ewmh_update_current_desktop();
2060
2061     startup_sequence_rename_workspace(old_name_copy, new_name);
2062     free(old_name_copy);
2063 }
2064
2065 /*
2066  * Implementation of 'bar mode dock|hide|invisible|toggle [<bar_id>]'
2067  *
2068  */
2069 bool cmd_bar_mode(const char *bar_mode, const char *bar_id) {
2070     int mode = M_DOCK;
2071     bool toggle = false;
2072     if (strcmp(bar_mode, "dock") == 0)
2073         mode = M_DOCK;
2074     else if (strcmp(bar_mode, "hide") == 0)
2075         mode = M_HIDE;
2076     else if (strcmp(bar_mode, "invisible") == 0)
2077         mode = M_INVISIBLE;
2078     else if (strcmp(bar_mode, "toggle") == 0)
2079         toggle = true;
2080     else {
2081         ELOG("Unknown bar mode \"%s\", this is a mismatch between code and parser spec.\n", bar_mode);
2082         return false;
2083     }
2084
2085     bool changed_sth = false;
2086     Barconfig *current = NULL;
2087     TAILQ_FOREACH(current, &barconfigs, configs) {
2088         if (bar_id && strcmp(current->id, bar_id) != 0)
2089             continue;
2090
2091         if (toggle)
2092             mode = (current->mode + 1) % 2;
2093
2094         DLOG("Changing bar mode of bar_id '%s' to '%s (%d)'\n", current->id, bar_mode, mode);
2095         current->mode = mode;
2096         changed_sth = true;
2097
2098         if (bar_id)
2099             break;
2100     }
2101
2102     if (bar_id && !changed_sth) {
2103         DLOG("Changing bar mode of bar_id %s failed, bar_id not found.\n", bar_id);
2104         return false;
2105     }
2106
2107     return true;
2108 }
2109
2110 /*
2111  * Implementation of 'bar hidden_state hide|show|toggle [<bar_id>]'
2112  *
2113  */
2114 bool cmd_bar_hidden_state(const char *bar_hidden_state, const char *bar_id) {
2115     int hidden_state = S_SHOW;
2116     bool toggle = false;
2117     if (strcmp(bar_hidden_state, "hide") == 0)
2118         hidden_state = S_HIDE;
2119     else if (strcmp(bar_hidden_state, "show") == 0)
2120         hidden_state = S_SHOW;
2121     else if (strcmp(bar_hidden_state, "toggle") == 0)
2122         toggle = true;
2123     else {
2124         ELOG("Unknown bar state \"%s\", this is a mismatch between code and parser spec.\n", bar_hidden_state);
2125         return false;
2126     }
2127
2128     bool changed_sth = false;
2129     Barconfig *current = NULL;
2130     TAILQ_FOREACH(current, &barconfigs, configs) {
2131         if (bar_id && strcmp(current->id, bar_id) != 0)
2132             continue;
2133
2134         if (toggle)
2135             hidden_state = (current->hidden_state + 1) % 2;
2136
2137         DLOG("Changing bar hidden_state of bar_id '%s' to '%s (%d)'\n", current->id, bar_hidden_state, hidden_state);
2138         current->hidden_state = hidden_state;
2139         changed_sth = true;
2140
2141         if (bar_id)
2142             break;
2143     }
2144
2145     if (bar_id && !changed_sth) {
2146         DLOG("Changing bar hidden_state of bar_id %s failed, bar_id not found.\n", bar_id);
2147         return false;
2148     }
2149
2150     return true;
2151 }
2152
2153 /*
2154  * Implementation of 'bar (hidden_state hide|show|toggle)|(mode dock|hide|invisible|toggle) [<bar_id>]'
2155  *
2156  */
2157 void cmd_bar(I3_CMD, const char *bar_type, const char *bar_value, const char *bar_id) {
2158     bool ret;
2159     if (strcmp(bar_type, "mode") == 0)
2160         ret = cmd_bar_mode(bar_value, bar_id);
2161     else if (strcmp(bar_type, "hidden_state") == 0)
2162         ret = cmd_bar_hidden_state(bar_value, bar_id);
2163     else {
2164         ELOG("Unknown bar option type \"%s\", this is a mismatch between code and parser spec.\n", bar_type);
2165         ret = false;
2166     }
2167
2168     ysuccess(ret);
2169     if (!ret)
2170         return;
2171
2172     update_barconfig();
2173 }
2174
2175 /*
2176  * Implementation of 'shmlog <size>|toggle|on|off'
2177  *
2178  */
2179 void cmd_shmlog(I3_CMD, const char *argument) {
2180     if (!strcmp(argument, "toggle"))
2181         /* Toggle shm log, if size is not 0. If it is 0, set it to default. */
2182         shmlog_size = shmlog_size ? -shmlog_size : default_shmlog_size;
2183     else if (!strcmp(argument, "on"))
2184         shmlog_size = default_shmlog_size;
2185     else if (!strcmp(argument, "off"))
2186         shmlog_size = 0;
2187     else {
2188         /* If shm logging now, restart logging with the new size. */
2189         if (shmlog_size > 0) {
2190             shmlog_size = 0;
2191             LOG("Restarting shm logging...\n");
2192             init_logging();
2193         }
2194         shmlog_size = atoi(argument);
2195         /* Make a weakly attempt at ensuring the argument is valid. */
2196         if (shmlog_size <= 0)
2197             shmlog_size = default_shmlog_size;
2198     }
2199     LOG("%s shm logging\n", shmlog_size > 0 ? "Enabling" : "Disabling");
2200     init_logging();
2201     update_shmlog_atom();
2202     // XXX: default reply for now, make this a better reply
2203     ysuccess(true);
2204 }
2205
2206 /*
2207  * Implementation of 'debuglog toggle|on|off'
2208  *
2209  */
2210 void cmd_debuglog(I3_CMD, const char *argument) {
2211     bool logging = get_debug_logging();
2212     if (!strcmp(argument, "toggle")) {
2213         LOG("%s debug logging\n", logging ? "Disabling" : "Enabling");
2214         set_debug_logging(!logging);
2215     } else if (!strcmp(argument, "on") && !logging) {
2216         LOG("Enabling debug logging\n");
2217         set_debug_logging(true);
2218     } else if (!strcmp(argument, "off") && logging) {
2219         LOG("Disabling debug logging\n");
2220         set_debug_logging(false);
2221     }
2222     // XXX: default reply for now, make this a better reply
2223     ysuccess(true);
2224 }