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-2012 Michael Stapelberg and contributors (see also: LICENSE)
   6  *
   7  * commands.c: all command functions (see commands_parser.c)
   8  *
   9  */
  10 #include <float.h>
  11 #include <stdarg.h>
  12
  13 #include "all.h"
  14
  15 /** When the command did not include match criteria (!), we use the currently
  16  * focused command. Do not confuse this case with a command which included
  17  * criteria but which did not match any windows. This macro has to be called in
  18  * every command.
  19  */
  20 #define HANDLE_EMPTY_MATCH do { \
  21     if (match_is_empty(current_match)) { \
  22         owindow *ow = smalloc(sizeof(owindow)); \
  23         ow->con = focused; \
  24         TAILQ_INIT(&owindows); \
  25         TAILQ_INSERT_TAIL(&owindows, ow, owindows); \
  26     } \
  27 } while (0)
  28
  29 static owindows_head owindows;
  30
  31 /*
  32  * Returns true if a is definitely greater than b (using the given epsilon)
  33  *
  34  */
  35 static bool definitelyGreaterThan(float a, float b, float epsilon) {
  36     return (a - b) > ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
  37 }
  38
  39 /*
  40  * Returns an 'output' corresponding to one of left/right/down/up or a specific
  41  * output name.
  42  *
  43  */
  44 static Output *get_output_from_string(Output *current_output, const char *output_str) {
  45     Output *output;
  46
  47     if (strcasecmp(output_str, "left") == 0) {
  48         output = get_output_next(D_LEFT, current_output);
  49         if (!output)
  50             output = get_output_most(D_RIGHT, current_output);
  51     } else if (strcasecmp(output_str, "right") == 0) {
  52         output = get_output_next(D_RIGHT, current_output);
  53         if (!output)
  54             output = get_output_most(D_LEFT, current_output);
  55     } else if (strcasecmp(output_str, "up") == 0) {
  56         output = get_output_next(D_UP, current_output);
  57         if (!output)
  58             output = get_output_most(D_DOWN, current_output);
  59     } else if (strcasecmp(output_str, "down") == 0) {
  60         output = get_output_next(D_DOWN, current_output);
  61         if (!output)
  62             output = get_output_most(D_UP, current_output);
  63     } else output = get_output_by_name(output_str);
  64
  65     return output;
  66 }
  67
  68 // This code is commented out because we might recycle it for popping up error
  69 // messages on parser errors.
  70 #if 0
  71 static pid_t migration_pid = -1;
  72
  73 /*
  74  * Handler which will be called when we get a SIGCHLD for the nagbar, meaning
  75  * it exited (or could not be started, depending on the exit code).
  76  *
  77  */
  78 static void nagbar_exited(EV_P_ ev_child *watcher, int revents) {
  79     ev_child_stop(EV_A_ watcher);
  80     if (!WIFEXITED(watcher->rstatus)) {
  81         fprintf(stderr, "ERROR: i3-nagbar did not exit normally.\n");
  82         return;
  83     }
  84
  85     int exitcode = WEXITSTATUS(watcher->rstatus);
  86     printf("i3-nagbar process exited with status %d\n", exitcode);
  87     if (exitcode == 2) {
  88         fprintf(stderr, "ERROR: i3-nagbar could not be found. Is it correctly installed on your system?\n");
  89     }
  90
  91     migration_pid = -1;
  92 }
  93
  94 /* We need ev >= 4 for the following code. Since it is not *that* important (it
  95  * only makes sure that there are no i3-nagbar instances left behind) we still
  96  * support old systems with libev 3. */
  97 #if EV_VERSION_MAJOR >= 4
  98 /*
  99  * Cleanup handler. Will be called when i3 exits. Kills i3-nagbar with signal
 100  * SIGKILL (9) to make sure there are no left-over i3-nagbar processes.
 101  *
 102  */
 103 static void nagbar_cleanup(EV_P_ ev_cleanup *watcher, int revent) {
 104     if (migration_pid != -1) {
 105         LOG("Sending SIGKILL (9) to i3-nagbar with PID %d\n", migration_pid);
 106         kill(migration_pid, SIGKILL);
 107     }
 108 }
 109 #endif
 110
 111 void cmd_MIGRATION_start_nagbar() {
 112     if (migration_pid != -1) {
 113         fprintf(stderr, "i3-nagbar already running.\n");
 114         return;
 115     }
 116     fprintf(stderr, "Starting i3-nagbar, command parsing differs from expected output.\n");
 117     ELOG("Please report this on IRC or in the bugtracker. Make sure to include the full debug level logfile:\n");
 118     ELOG("i3-dump-log | gzip -9c > /tmp/i3.log.gz\n");
 119     ELOG("FYI: Your i3 version is " I3_VERSION "\n");
 120     migration_pid = fork();
 121     if (migration_pid == -1) {
 122         warn("Could not fork()");
 123         return;
 124     }
 125
 126     /* child */
 127     if (migration_pid == 0) {
 128         char *pageraction;
 129         sasprintf(&pageraction, "i3-sensible-terminal -e i3-sensible-pager \"%s\"", errorfilename);
 130         char *argv[] = {
 131             NULL, /* will be replaced by the executable path */
 132             "-t",
 133             "error",
 134             "-m",
 135             "You found a parsing error. Please, please, please, report it!",
 136             "-b",
 137             "show errors",
 138             pageraction,
 139             NULL
 140         };
 141         exec_i3_utility("i3-nagbar", argv);
 142     }
 143
 144     /* parent */
 145     /* install a child watcher */
 146     ev_child *child = smalloc(sizeof(ev_child));
 147     ev_child_init(child, &nagbar_exited, migration_pid, 0);
 148     ev_child_start(main_loop, child);
 149
 150 /* We need ev >= 4 for the following code. Since it is not *that* important (it
 151  * only makes sure that there are no i3-nagbar instances left behind) we still
 152  * support old systems with libev 3. */
 153 #if EV_VERSION_MAJOR >= 4
 154     /* install a cleanup watcher (will be called when i3 exits and i3-nagbar is
 155      * still running) */
 156     ev_cleanup *cleanup = smalloc(sizeof(ev_cleanup));
 157     ev_cleanup_init(cleanup, nagbar_cleanup);
 158     ev_cleanup_start(main_loop, cleanup);
 159 #endif
 160 }
 161
 162 #endif
 163
 164 /*******************************************************************************
 165  * Criteria functions.
 166  ******************************************************************************/
 167
 168 /*
 169  * Initializes the specified 'Match' data structure and the initial state of
 170  * commands.c for matching target windows of a command.
 171  *
 172  */
 173 char *cmd_criteria_init(Match *current_match) {
 174     Con *con;
 175     owindow *ow;
 176
 177     DLOG("Initializing criteria, current_match = %p\n", current_match);
 178     match_init(current_match);
 179     while (!TAILQ_EMPTY(&owindows)) {
 180         ow = TAILQ_FIRST(&owindows);
 181         TAILQ_REMOVE(&owindows, ow, owindows);
 182         free(ow);
 183     }
 184     TAILQ_INIT(&owindows);
 185     /* copy all_cons */
 186     TAILQ_FOREACH(con, &all_cons, all_cons) {
 187         ow = smalloc(sizeof(owindow));
 188         ow->con = con;
 189         TAILQ_INSERT_TAIL(&owindows, ow, owindows);
 190     }
 191
 192     /* This command is internal and does not generate a JSON reply. */
 193     return NULL;
 194 }
 195
 196 /*
 197  * A match specification just finished (the closing square bracket was found),
 198  * so we filter the list of owindows.
 199  *
 200  */
 201 char *cmd_criteria_match_windows(Match *current_match) {
 202     owindow *next, *current;
 203
 204     DLOG("match specification finished, matching...\n");
 205     /* copy the old list head to iterate through it and start with a fresh
 206      * list which will contain only matching windows */
 207     struct owindows_head old = owindows;
 208     TAILQ_INIT(&owindows);
 209     for (next = TAILQ_FIRST(&old); next != TAILQ_END(&old);) {
 210         /* make a copy of the next pointer and advance the pointer to the
 211          * next element as we are going to invalidate the element’s
 212          * next/prev pointers by calling TAILQ_INSERT_TAIL later */
 213         current = next;
 214         next = TAILQ_NEXT(next, owindows);
 215
 216         DLOG("checking if con %p / %s matches\n", current->con, current->con->name);
 217         if (current_match->con_id != NULL) {
 218             if (current_match->con_id == current->con) {
 219                 DLOG("matches container!\n");
 220                 TAILQ_INSERT_TAIL(&owindows, current, owindows);
 221             }
 222         } else if (current_match->mark != NULL && current->con->mark != NULL &&
 223                    regex_matches(current_match->mark, current->con->mark)) {
 224             DLOG("match by mark\n");
 225             TAILQ_INSERT_TAIL(&owindows, current, owindows);
 226         } else {
 227             if (current->con->window == NULL)
 228                 continue;
 229             if (match_matches_window(current_match, current->con->window)) {
 230                 DLOG("matches window!\n");
 231                 TAILQ_INSERT_TAIL(&owindows, current, owindows);
 232             } else {
 233                 DLOG("doesnt match\n");
 234                 free(current);
 235             }
 236         }
 237     }
 238
 239     TAILQ_FOREACH(current, &owindows, owindows) {
 240         DLOG("matching: %p / %s\n", current->con, current->con->name);
 241     }
 242
 243     /* This command is internal and does not generate a JSON reply. */
 244     return NULL;
 245 }
 246
 247 /*
 248  * Interprets a ctype=cvalue pair and adds it to the current match
 249  * specification.
 250  *
 251  */
 252 char *cmd_criteria_add(Match *current_match, char *ctype, char *cvalue) {
 253     DLOG("ctype=*%s*, cvalue=*%s*\n", ctype, cvalue);
 254
 255     if (strcmp(ctype, "class") == 0) {
 256         current_match->class = regex_new(cvalue);
 257         return NULL;
 258     }
 259
 260     if (strcmp(ctype, "instance") == 0) {
 261         current_match->instance = regex_new(cvalue);
 262         return NULL;
 263     }
 264
 265     if (strcmp(ctype, "window_role") == 0) {
 266         current_match->role = regex_new(cvalue);
 267         return NULL;
 268     }
 269
 270     if (strcmp(ctype, "con_id") == 0) {
 271         char *end;
 272         long parsed = strtol(cvalue, &end, 10);
 273         if (parsed == LONG_MIN ||
 274             parsed == LONG_MAX ||
 275             parsed < 0 ||
 276             (end && *end != '\0')) {
 277             ELOG("Could not parse con id \"%s\"\n", cvalue);
 278         } else {
 279             current_match->con_id = (Con*)parsed;
 280             printf("id as int = %p\n", current_match->con_id);
 281         }
 282         return NULL;
 283     }
 284
 285     if (strcmp(ctype, "id") == 0) {
 286         char *end;
 287         long parsed = strtol(cvalue, &end, 10);
 288         if (parsed == LONG_MIN ||
 289             parsed == LONG_MAX ||
 290             parsed < 0 ||
 291             (end && *end != '\0')) {
 292             ELOG("Could not parse window id \"%s\"\n", cvalue);
 293         } else {
 294             current_match->id = parsed;
 295             printf("window id as int = %d\n", current_match->id);
 296         }
 297         return NULL;
 298     }
 299
 300     if (strcmp(ctype, "con_mark") == 0) {
 301         current_match->mark = regex_new(cvalue);
 302         return NULL;
 303     }
 304
 305     if (strcmp(ctype, "title") == 0) {
 306         current_match->title = regex_new(cvalue);
 307         return NULL;
 308     }
 309
 310     if (strcmp(ctype, "urgent") == 0) {
 311         if (strcasecmp(cvalue, "latest") == 0 ||
 312             strcasecmp(cvalue, "newest") == 0 ||
 313             strcasecmp(cvalue, "recent") == 0 ||
 314             strcasecmp(cvalue, "last") == 0) {
 315             current_match->urgent = U_LATEST;
 316         } else if (strcasecmp(cvalue, "oldest") == 0 ||
 317                    strcasecmp(cvalue, "first") == 0) {
 318             current_match->urgent = U_OLDEST;
 319         }
 320         return NULL;
 321     }
 322
 323     ELOG("Unknown criterion: %s\n", ctype);
 324
 325     /* This command is internal and does not generate a JSON reply. */
 326     return NULL;
 327 }
 328
 329 /*
 330  * Implementation of 'move [window|container] [to] workspace
 331  * next|prev|next_on_output|prev_on_output'.
 332  *
 333  */
 334 char *cmd_move_con_to_workspace(Match *current_match, char *which) {
 335     owindow *current;
 336
 337     DLOG("which=%s\n", which);
 338
 339     HANDLE_EMPTY_MATCH;
 340
 341     /* get the workspace */
 342     Con *ws;
 343     if (strcmp(which, "next") == 0)
 344         ws = workspace_next();
 345     else if (strcmp(which, "prev") == 0)
 346         ws = workspace_prev();
 347     else if (strcmp(which, "next_on_output") == 0)
 348         ws = workspace_next_on_output();
 349     else if (strcmp(which, "prev_on_output") == 0)
 350         ws = workspace_prev_on_output();
 351     else {
 352         ELOG("BUG: called with which=%s\n", which);
 353         return sstrdup("{\"sucess\": false}");
 354     }
 355
 356     TAILQ_FOREACH(current, &owindows, owindows) {
 357         DLOG("matching: %p / %s\n", current->con, current->con->name);
 358         con_move_to_workspace(current->con, ws, true, false);
 359     }
 360
 361     tree_render();
 362
 363     // XXX: default reply for now, make this a better reply
 364     return sstrdup("{\"success\": true}");
 365 }
 366
 367 /*
 368  * Implementation of 'move [window|container] [to] workspace <name>'.
 369  *
 370  */
 371 char *cmd_move_con_to_workspace_name(Match *current_match, char *name) {
 372     if (strncasecmp(name, "__i3_", strlen("__i3_")) == 0) {
 373         LOG("You cannot switch to the i3 internal workspaces.\n");
 374         return sstrdup("{\"sucess\": false}");
 375     }
 376
 377     owindow *current;
 378
 379     /* Error out early to not create a non-existing workspace (in
 380      * workspace_get()) if we are not actually able to move anything. */
 381     if (match_is_empty(current_match) && focused->type == CT_WORKSPACE)
 382         return sstrdup("{\"sucess\": false}");
 383
 384     LOG("should move window to workspace %s\n", name);
 385     /* get the workspace */
 386     Con *ws = workspace_get(name, NULL);
 387
 388     HANDLE_EMPTY_MATCH;
 389
 390     TAILQ_FOREACH(current, &owindows, owindows) {
 391         DLOG("matching: %p / %s\n", current->con, current->con->name);
 392         con_move_to_workspace(current->con, ws, true, false);
 393     }
 394
 395     tree_render();
 396
 397     // XXX: default reply for now, make this a better reply
 398     return sstrdup("{\"success\": true}");
 399 }
 400
 401 /*
 402  * Implementation of 'resize grow|shrink <direction> [<px> px] [or <ppt> ppt]'.
 403  *
 404  */
 405 char *cmd_resize(Match *current_match, char *way, char *direction, char *resize_px, char *resize_ppt) {
 406     /* resize <grow|shrink> <direction> [<px> px] [or <ppt> ppt] */
 407     DLOG("resizing in way %s, direction %s, px %s or ppt %s\n", way, direction, resize_px, resize_ppt);
 408     // TODO: We could either handle this in the parser itself as a separate token (and make the stack typed) or we need a better way to convert a string to a number with error checking
 409     int px = atoi(resize_px);
 410     int ppt = atoi(resize_ppt);
 411     if (strcmp(way, "shrink") == 0) {
 412         px *= -1;
 413         ppt *= -1;
 414     }
 415
 416     Con *floating_con;
 417     if ((floating_con = con_inside_floating(focused))) {
 418         printf("floating resize\n");
 419         if (strcmp(direction, "up") == 0) {
 420             floating_con->rect.y -= px;
 421             floating_con->rect.height += px;
 422         } else if (strcmp(direction, "down") == 0) {
 423             floating_con->rect.height += px;
 424         } else if (strcmp(direction, "left") == 0) {
 425             floating_con->rect.x -= px;
 426             floating_con->rect.width += px;
 427         } else {
 428             floating_con->rect.width += px;
 429         }
 430     } else {
 431         LOG("tiling resize\n");
 432         /* get the appropriate current container (skip stacked/tabbed cons) */
 433         Con *current = focused;
 434         while (current->parent->layout == L_STACKED ||
 435                current->parent->layout == L_TABBED)
 436             current = current->parent;
 437
 438         /* Then further go up until we find one with the matching orientation. */
 439         orientation_t search_orientation =
 440             (strcmp(direction, "left") == 0 || strcmp(direction, "right") == 0 ? HORIZ : VERT);
 441
 442         while (current->type != CT_WORKSPACE &&
 443                current->type != CT_FLOATING_CON &&
 444                current->parent->orientation != search_orientation)
 445             current = current->parent;
 446
 447         /* get the default percentage */
 448         int children = con_num_children(current->parent);
 449         Con *other;
 450         LOG("ins. %d children\n", children);
 451         double percentage = 1.0 / children;
 452         LOG("default percentage = %f\n", percentage);
 453
 454         orientation_t orientation = current->parent->orientation;
 455
 456         if ((orientation == HORIZ &&
 457              (strcmp(direction, "up") == 0 || strcmp(direction, "down") == 0)) ||
 458             (orientation == VERT &&
 459              (strcmp(direction, "left") == 0 || strcmp(direction, "right") == 0))) {
 460             LOG("You cannot resize in that direction. Your focus is in a %s split container currently.\n",
 461                 (orientation == HORIZ ? "horizontal" : "vertical"));
 462             return sstrdup("{\"sucess\": false}");
 463         }
 464
 465         if (strcmp(direction, "up") == 0 || strcmp(direction, "left") == 0) {
 466             other = TAILQ_PREV(current, nodes_head, nodes);
 467         } else {
 468             other = TAILQ_NEXT(current, nodes);
 469         }
 470         if (other == TAILQ_END(workspaces)) {
 471             LOG("No other container in this direction found, cannot resize.\n");
 472             return sstrdup("{\"sucess\": false}");
 473         }
 474         LOG("other->percent = %f\n", other->percent);
 475         LOG("current->percent before = %f\n", current->percent);
 476         if (current->percent == 0.0)
 477             current->percent = percentage;
 478         if (other->percent == 0.0)
 479             other->percent = percentage;
 480         double new_current_percent = current->percent + ((double)ppt / 100.0);
 481         double new_other_percent = other->percent - ((double)ppt / 100.0);
 482         LOG("new_current_percent = %f\n", new_current_percent);
 483         LOG("new_other_percent = %f\n", new_other_percent);
 484         /* Ensure that the new percentages are positive and greater than
 485          * 0.05 to have a reasonable minimum size. */
 486         if (definitelyGreaterThan(new_current_percent, 0.05, DBL_EPSILON) &&
 487             definitelyGreaterThan(new_other_percent, 0.05, DBL_EPSILON)) {
 488             current->percent += ((double)ppt / 100.0);
 489             other->percent -= ((double)ppt / 100.0);
 490             LOG("current->percent after = %f\n", current->percent);
 491             LOG("other->percent after = %f\n", other->percent);
 492         } else {
 493             LOG("Not resizing, already at minimum size\n");
 494         }
 495     }
 496
 497     tree_render();
 498
 499     // XXX: default reply for now, make this a better reply
 500     return sstrdup("{\"success\": true}");
 501 }
 502
 503 /*
 504  * Implementation of 'border normal|none|1pixel|toggle'.
 505  *
 506  */
 507 char *cmd_border(Match *current_match, char *border_style_str) {
 508     DLOG("border style should be changed to %s\n", border_style_str);
 509     owindow *current;
 510
 511     HANDLE_EMPTY_MATCH;
 512
 513     TAILQ_FOREACH(current, &owindows, owindows) {
 514         DLOG("matching: %p / %s\n", current->con, current->con->name);
 515         int border_style = current->con->border_style;
 516         if (strcmp(border_style_str, "toggle") == 0) {
 517             border_style++;
 518             border_style %= 3;
 519         } else {
 520             if (strcmp(border_style_str, "normal") == 0)
 521                 border_style = BS_NORMAL;
 522             else if (strcmp(border_style_str, "none") == 0)
 523                 border_style = BS_NONE;
 524             else if (strcmp(border_style_str, "1pixel") == 0)
 525                 border_style = BS_1PIXEL;
 526             else {
 527                 ELOG("BUG: called with border_style=%s\n", border_style_str);
 528                 return sstrdup("{\"sucess\": false}");
 529             }
 530         }
 531         con_set_border_style(current->con, border_style);
 532     }
 533
 534     tree_render();
 535
 536     // XXX: default reply for now, make this a better reply
 537     return sstrdup("{\"success\": true}");
 538 }
 539
 540 /*
 541  * Implementation of 'nop <comment>'.
 542  *
 543  */
 544 char *cmd_nop(Match *current_match, char *comment) {
 545     LOG("-------------------------------------------------\n");
 546     LOG("  NOP: %s\n", comment);
 547     LOG("-------------------------------------------------\n");
 548
 549     return NULL;
 550 }
 551
 552 /*
 553  * Implementation of 'append_layout <path>'.
 554  *
 555  */
 556 char *cmd_append_layout(Match *current_match, char *path) {
 557     LOG("Appending layout \"%s\"\n", path);
 558     tree_append_json(path);
 559     tree_render();
 560
 561     // XXX: default reply for now, make this a better reply
 562     return sstrdup("{\"success\": true}");
 563 }
 564
 565 /*
 566  * Implementation of 'workspace next|prev|next_on_output|prev_on_output'.
 567  *
 568  */
 569 char *cmd_workspace(Match *current_match, char *which) {
 570     Con *ws;
 571
 572     DLOG("which=%s\n", which);
 573
 574     if (strcmp(which, "next") == 0)
 575         ws = workspace_next();
 576     else if (strcmp(which, "prev") == 0)
 577         ws = workspace_prev();
 578     else if (strcmp(which, "next_on_output") == 0)
 579         ws = workspace_next_on_output();
 580     else if (strcmp(which, "prev_on_output") == 0)
 581         ws = workspace_prev_on_output();
 582     else {
 583         ELOG("BUG: called with which=%s\n", which);
 584         return sstrdup("{\"sucess\": false}");
 585     }
 586
 587     workspace_show(ws);
 588     tree_render();
 589
 590     // XXX: default reply for now, make this a better reply
 591     return sstrdup("{\"success\": true}");
 592 }
 593
 594 /*
 595  * Implementation of 'workspace back_and_forth'.
 596  *
 597  */
 598 char *cmd_workspace_back_and_forth(Match *current_match) {
 599     workspace_back_and_forth();
 600     tree_render();
 601
 602     // XXX: default reply for now, make this a better reply
 603     return sstrdup("{\"success\": true}");
 604 }
 605
 606 /*
 607  * Implementation of 'workspace <name>'
 608  *
 609  */
 610 char *cmd_workspace_name(Match *current_match, char *name) {
 611     if (strncasecmp(name, "__i3_", strlen("__i3_")) == 0) {
 612         LOG("You cannot switch to the i3 internal workspaces.\n");
 613         return sstrdup("{\"sucess\": false}");
 614     }
 615
 616     DLOG("should switch to workspace %s\n", name);
 617
 618     Con *ws = con_get_workspace(focused);
 619
 620     /* Check if the command wants to switch to the current workspace */
 621     if (strcmp(ws->name, name) == 0) {
 622         DLOG("This workspace is already focused.\n");
 623         if (config.workspace_auto_back_and_forth) {
 624             workspace_back_and_forth();
 625             tree_render();
 626         }
 627         return sstrdup("{\"sucess\": false}");
 628     }
 629
 630     workspace_show_by_name(name);
 631
 632     tree_render();
 633
 634     // XXX: default reply for now, make this a better reply
 635     return sstrdup("{\"success\": true}");
 636 }
 637
 638 /*
 639  * Implementation of 'mark <mark>'
 640  *
 641  */
 642 char *cmd_mark(Match *current_match, char *mark) {
 643     DLOG("Clearing all windows which have that mark first\n");
 644
 645     Con *con;
 646     TAILQ_FOREACH(con, &all_cons, all_cons) {
 647         if (con->mark && strcmp(con->mark, mark) == 0)
 648             FREE(con->mark);
 649     }
 650
 651     DLOG("marking window with str %s\n", mark);
 652     owindow *current;
 653
 654     HANDLE_EMPTY_MATCH;
 655
 656     TAILQ_FOREACH(current, &owindows, owindows) {
 657         DLOG("matching: %p / %s\n", current->con, current->con->name);
 658         current->con->mark = sstrdup(mark);
 659     }
 660
 661     tree_render();
 662
 663     // XXX: default reply for now, make this a better reply
 664     return sstrdup("{\"success\": true}");
 665 }
 666
 667 /*
 668  * Implementation of 'mode <string>'.
 669  *
 670  */
 671 char *cmd_mode(Match *current_match, char *mode) {
 672     DLOG("mode=%s\n", mode);
 673     switch_mode(mode);
 674
 675     // XXX: default reply for now, make this a better reply
 676     return sstrdup("{\"success\": true}");
 677 }
 678
 679 /*
 680  * Implementation of 'move [window|container] [to] output <str>'.
 681  *
 682  */
 683 char *cmd_move_con_to_output(Match *current_match, char *name) {
 684     owindow *current;
 685
 686     DLOG("should move window to output %s\n", name);
 687
 688     HANDLE_EMPTY_MATCH;
 689
 690     /* get the output */
 691     Output *current_output = NULL;
 692     Output *output;
 693
 694     // TODO: fix the handling of criteria
 695     TAILQ_FOREACH(current, &owindows, owindows)
 696         current_output = get_output_containing(current->con->rect.x, current->con->rect.y);
 697
 698     assert(current_output != NULL);
 699
 700     // TODO: clean this up with commands.spec as soon as we switched away from the lex/yacc command parser
 701     if (strcasecmp(name, "up") == 0)
 702         output = get_output_next(D_UP, current_output);
 703     else if (strcasecmp(name, "down") == 0)
 704         output = get_output_next(D_DOWN, current_output);
 705     else if (strcasecmp(name, "left") == 0)
 706         output = get_output_next(D_LEFT, current_output);
 707     else if (strcasecmp(name, "right") == 0)
 708         output = get_output_next(D_RIGHT, current_output);
 709     else
 710         output = get_output_by_name(name);
 711
 712     if (!output) {
 713         LOG("No such output found.\n");
 714         return sstrdup("{\"sucess\": false}");
 715     }
 716
 717     /* get visible workspace on output */
 718     Con *ws = NULL;
 719     GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
 720     if (!ws)
 721         return sstrdup("{\"sucess\": false}");
 722
 723     TAILQ_FOREACH(current, &owindows, owindows) {
 724         DLOG("matching: %p / %s\n", current->con, current->con->name);
 725         con_move_to_workspace(current->con, ws, true, false);
 726     }
 727
 728     tree_render();
 729
 730     // XXX: default reply for now, make this a better reply
 731     return sstrdup("{\"success\": true}");
 732 }
 733
 734 /*
 735  * Implementation of 'floating enable|disable|toggle'
 736  *
 737  */
 738 char *cmd_floating(Match *current_match, char *floating_mode) {
 739     owindow *current;
 740
 741     DLOG("floating_mode=%s\n", floating_mode);
 742
 743     HANDLE_EMPTY_MATCH;
 744
 745     TAILQ_FOREACH(current, &owindows, owindows) {
 746         DLOG("matching: %p / %s\n", current->con, current->con->name);
 747         if (strcmp(floating_mode, "toggle") == 0) {
 748             DLOG("should toggle mode\n");
 749             toggle_floating_mode(current->con, false);
 750         } else {
 751             DLOG("should switch mode to %s\n", floating_mode);
 752             if (strcmp(floating_mode, "enable") == 0) {
 753                 floating_enable(current->con, false);
 754             } else {
 755                 floating_disable(current->con, false);
 756             }
 757         }
 758     }
 759
 760     tree_render();
 761
 762     // XXX: default reply for now, make this a better reply
 763     return sstrdup("{\"success\": true}");
 764 }
 765
 766 /*
 767  * Implementation of 'move workspace to [output] <str>'.
 768  *
 769  */
 770 char *cmd_move_workspace_to_output(Match *current_match, char *name) {
 771     DLOG("should move workspace to output %s\n", name);
 772
 773     HANDLE_EMPTY_MATCH;
 774
 775     owindow *current;
 776     TAILQ_FOREACH(current, &owindows, owindows) {
 777         Output *current_output = get_output_containing(current->con->rect.x,
 778                                                        current->con->rect.y);
 779         Output *output = get_output_from_string(current_output, name);
 780         if (!output) {
 781             LOG("No such output\n");
 782             return sstrdup("{\"sucess\": false}");
 783         }
 784
 785         Con *content = output_get_content(output->con);
 786         LOG("got output %p with content %p\n", output, content);
 787
 788         Con *ws = con_get_workspace(current->con);
 789         LOG("should move workspace %p / %s\n", ws, ws->name);
 790
 791         if (con_num_children(ws->parent) == 1) {
 792             LOG("Creating a new workspace to replace \"%s\" (last on its output).\n", ws->name);
 793
 794             /* check if we can find a workspace assigned to this output */
 795             bool used_assignment = false;
 796             struct Workspace_Assignment *assignment;
 797             TAILQ_FOREACH(assignment, &ws_assignments, ws_assignments) {
 798                 if (strcmp(assignment->output, current_output->name) != 0)
 799                     continue;
 800
 801                 /* check if this workspace is already attached to the tree */
 802                 Con *workspace = NULL, *out;
 803                 TAILQ_FOREACH(out, &(croot->nodes_head), nodes)
 804                     GREP_FIRST(workspace, output_get_content(out),
 805                                !strcasecmp(child->name, assignment->name));
 806                 if (workspace != NULL)
 807                     continue;
 808
 809                 /* so create the workspace referenced to by this assignment */
 810                 LOG("Creating workspace from assignment %s.\n", assignment->name);
 811                 workspace_get(assignment->name, NULL);
 812                 used_assignment = true;
 813                 break;
 814             }
 815
 816             /* if we couldn't create the workspace using an assignment, create
 817              * it on the output */
 818             if (!used_assignment)
 819                 create_workspace_on_output(current_output, ws->parent);
 820
 821             /* notify the IPC listeners */
 822             ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"init\"}");
 823         }
 824
 825         bool workspace_was_visible = workspace_is_visible(ws);
 826         Con *old_content = ws->parent;
 827         con_detach(ws);
 828         if (workspace_was_visible) {
 829             /* The workspace which we just detached was visible, so focus
 830              * the next one in the focus-stack. */
 831             Con *focus_ws = TAILQ_FIRST(&(old_content->focus_head));
 832             LOG("workspace was visible, focusing %p / %s now\n", focus_ws, focus_ws->name);
 833             workspace_show(focus_ws);
 834         }
 835         con_attach(ws, content, false);
 836         ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"move\"}");
 837         if (workspace_was_visible) {
 838             /* Focus the moved workspace on the destination output. */
 839             workspace_show(ws);
 840         }
 841     }
 842
 843     tree_render();
 844
 845     // XXX: default reply for now, make this a better reply
 846     return sstrdup("{\"success\": true}");
 847 }
 848
 849 /*
 850  * Implementation of 'split v|h|vertical|horizontal'.
 851  *
 852  */
 853 char *cmd_split(Match *current_match, char *direction) {
 854     /* TODO: use matches */
 855     LOG("splitting in direction %c\n", direction[0]);
 856     tree_split(focused, (direction[0] == 'v' ? VERT : HORIZ));
 857
 858     tree_render();
 859
 860     // XXX: default reply for now, make this a better reply
 861     return sstrdup("{\"success\": true}");
 862 }
 863
 864 /*
 865  * Implementaiton of 'kill [window|client]'.
 866  *
 867  */
 868 char *cmd_kill(Match *current_match, char *kill_mode_str) {
 869     if (kill_mode_str == NULL)
 870         kill_mode_str = "window";
 871     owindow *current;
 872
 873     DLOG("kill_mode=%s\n", kill_mode_str);
 874
 875     int kill_mode;
 876     if (strcmp(kill_mode_str, "window") == 0)
 877         kill_mode = KILL_WINDOW;
 878     else if (strcmp(kill_mode_str, "client") == 0)
 879         kill_mode = KILL_CLIENT;
 880     else {
 881         ELOG("BUG: called with kill_mode=%s\n", kill_mode_str);
 882         return sstrdup("{\"sucess\": false}");
 883     }
 884
 885     /* check if the match is empty, not if the result is empty */
 886     if (match_is_empty(current_match))
 887         tree_close_con(kill_mode);
 888     else {
 889         TAILQ_FOREACH(current, &owindows, owindows) {
 890             DLOG("matching: %p / %s\n", current->con, current->con->name);
 891             tree_close(current->con, kill_mode, false, false);
 892         }
 893     }
 894
 895     tree_render();
 896
 897     // XXX: default reply for now, make this a better reply
 898     return sstrdup("{\"success\": true}");
 899 }
 900
 901 /*
 902  * Implementation of 'exec [--no-startup-id] <command>'.
 903  *
 904  */
 905 char *cmd_exec(Match *current_match, char *nosn, char *command) {
 906     bool no_startup_id = (nosn != NULL);
 907
 908     DLOG("should execute %s, no_startup_id = %d\n", command, no_startup_id);
 909     start_application(command, no_startup_id);
 910
 911     // XXX: default reply for now, make this a better reply
 912     return sstrdup("{\"success\": true}");
 913 }
 914
 915 /*
 916  * Implementation of 'focus left|right|up|down'.
 917  *
 918  */
 919 char *cmd_focus_direction(Match *current_match, char *direction) {
 920     if (focused &&
 921         focused->type != CT_WORKSPACE &&
 922         focused->fullscreen_mode != CF_NONE) {
 923         LOG("Cannot change focus while in fullscreen mode.\n");
 924         return sstrdup("{\"sucess\": false}");
 925     }
 926
 927     DLOG("direction = *%s*\n", direction);
 928
 929     if (strcmp(direction, "left") == 0)
 930         tree_next('p', HORIZ);
 931     else if (strcmp(direction, "right") == 0)
 932         tree_next('n', HORIZ);
 933     else if (strcmp(direction, "up") == 0)
 934         tree_next('p', VERT);
 935     else if (strcmp(direction, "down") == 0)
 936         tree_next('n', VERT);
 937     else {
 938         ELOG("Invalid focus direction (%s)\n", direction);
 939         return sstrdup("{\"sucess\": false}");
 940     }
 941
 942     tree_render();
 943
 944     // XXX: default reply for now, make this a better reply
 945     return sstrdup("{\"success\": true}");
 946 }
 947
 948 /*
 949  * Implementation of 'focus tiling|floating|mode_toggle'.
 950  *
 951  */
 952 char *cmd_focus_window_mode(Match *current_match, char *window_mode) {
 953     if (focused &&
 954         focused->type != CT_WORKSPACE &&
 955         focused->fullscreen_mode != CF_NONE) {
 956         LOG("Cannot change focus while in fullscreen mode.\n");
 957         return sstrdup("{\"sucess\": false}");
 958     }
 959
 960     DLOG("window_mode = %s\n", window_mode);
 961
 962     Con *ws = con_get_workspace(focused);
 963     Con *current;
 964     if (ws != NULL) {
 965         if (strcmp(window_mode, "mode_toggle") == 0) {
 966             current = TAILQ_FIRST(&(ws->focus_head));
 967             if (current != NULL && current->type == CT_FLOATING_CON)
 968                 window_mode = "tiling";
 969             else window_mode = "floating";
 970         }
 971         TAILQ_FOREACH(current, &(ws->focus_head), focused) {
 972             if ((strcmp(window_mode, "floating") == 0 && current->type != CT_FLOATING_CON) ||
 973                 (strcmp(window_mode, "tiling") == 0 && current->type == CT_FLOATING_CON))
 974                 continue;
 975
 976             con_focus(con_descend_focused(current));
 977             break;
 978         }
 979     }
 980
 981     tree_render();
 982
 983     // XXX: default reply for now, make this a better reply
 984     return sstrdup("{\"success\": true}");
 985 }
 986
 987 /*
 988  * Implementation of 'focus parent|child'.
 989  *
 990  */
 991 char *cmd_focus_level(Match *current_match, char *level) {
 992     if (focused &&
 993         focused->type != CT_WORKSPACE &&
 994         focused->fullscreen_mode != CF_NONE) {
 995         LOG("Cannot change focus while in fullscreen mode.\n");
 996         return sstrdup("{\"sucess\": false}");
 997     }
 998
 999     DLOG("level = %s\n", level);
1000
1001     if (strcmp(level, "parent") == 0)
1002         level_up();
1003     else level_down();
1004
1005     tree_render();
1006
1007     // XXX: default reply for now, make this a better reply
1008     return sstrdup("{\"success\": true}");
1009 }
1010
1011 /*
1012  * Implementation of 'focus'.
1013  *
1014  */
1015 char *cmd_focus(Match *current_match) {
1016     DLOG("current_match = %p\n", current_match);
1017     if (focused &&
1018         focused->type != CT_WORKSPACE &&
1019         focused->fullscreen_mode != CF_NONE) {
1020         LOG("Cannot change focus while in fullscreen mode.\n");
1021         return sstrdup("{\"sucess\": false}");
1022     }
1023
1024     owindow *current;
1025
1026     if (match_is_empty(current_match)) {
1027         ELOG("You have to specify which window/container should be focused.\n");
1028         ELOG("Example: [class=\"urxvt\" title=\"irssi\"] focus\n");
1029
1030         char *json_output;
1031         sasprintf(&json_output, "{\"success\":false, \"error\":\"You have to "
1032                   "specify which window/container should be focused\"}");
1033         return json_output;
1034     }
1035
1036     int count = 0;
1037     TAILQ_FOREACH(current, &owindows, owindows) {
1038         Con *ws = con_get_workspace(current->con);
1039         /* If no workspace could be found, this was a dock window.
1040          * Just skip it, you cannot focus dock windows. */
1041         if (!ws)
1042             continue;
1043
1044         /* If the container is not on the current workspace,
1045          * workspace_show() will switch to a different workspace and (if
1046          * enabled) trigger a mouse pointer warp to the currently focused
1047          * container (!) on the target workspace.
1048          *
1049          * Therefore, before calling workspace_show(), we make sure that
1050          * 'current' will be focused on the workspace. However, we cannot
1051          * just con_focus(current) because then the pointer will not be
1052          * warped at all (the code thinks we are already there).
1053          *
1054          * So we focus 'current' to make it the currently focused window of
1055          * the target workspace, then revert focus. */
1056         Con *currently_focused = focused;
1057         con_focus(current->con);
1058         con_focus(currently_focused);
1059
1060         /* Now switch to the workspace, then focus */
1061         workspace_show(ws);
1062         LOG("focusing %p / %s\n", current->con, current->con->name);
1063         con_focus(current->con);
1064         count++;
1065     }
1066
1067     if (count > 1)
1068         LOG("WARNING: Your criteria for the focus command matches %d containers, "
1069             "while only exactly one container can be focused at a time.\n", count);
1070
1071     tree_render();
1072
1073     // XXX: default reply for now, make this a better reply
1074     return sstrdup("{\"success\": true}");
1075 }
1076
1077 /*
1078  * Implementation of 'fullscreen [global]'.
1079  *
1080  */
1081 char *cmd_fullscreen(Match *current_match, char *fullscreen_mode) {
1082     if (fullscreen_mode == NULL)
1083         fullscreen_mode = "output";
1084     DLOG("toggling fullscreen, mode = %s\n", fullscreen_mode);
1085     owindow *current;
1086
1087     HANDLE_EMPTY_MATCH;
1088
1089     TAILQ_FOREACH(current, &owindows, owindows) {
1090         printf("matching: %p / %s\n", current->con, current->con->name);
1091         con_toggle_fullscreen(current->con, (strcmp(fullscreen_mode, "global") == 0 ? CF_GLOBAL : CF_OUTPUT));
1092     }
1093
1094     tree_render();
1095
1096     // XXX: default reply for now, make this a better reply
1097     return sstrdup("{\"success\": true}");
1098 }
1099
1100 /*
1101  * Implementation of 'move <direction> [<pixels> [px]]'.
1102  *
1103  */
1104 char *cmd_move_direction(Match *current_match, char *direction, char *move_px) {
1105     // TODO: We could either handle this in the parser itself as a separate token (and make the stack typed) or we need a better way to convert a string to a number with error checking
1106     int px = atoi(move_px);
1107
1108     /* TODO: make 'move' work with criteria. */
1109     DLOG("moving in direction %s, px %s\n", direction, move_px);
1110     if (con_is_floating(focused)) {
1111         DLOG("floating move with %d pixels\n", px);
1112         Rect newrect = focused->parent->rect;
1113         if (strcmp(direction, "left") == 0) {
1114             newrect.x -= px;
1115         } else if (strcmp(direction, "right") == 0) {
1116             newrect.x += px;
1117         } else if (strcmp(direction, "up") == 0) {
1118             newrect.y -= px;
1119         } else if (strcmp(direction, "down") == 0) {
1120             newrect.y += px;
1121         }
1122         floating_reposition(focused->parent, newrect);
1123     } else {
1124         tree_move((strcmp(direction, "right") == 0 ? D_RIGHT :
1125                    (strcmp(direction, "left") == 0 ? D_LEFT :
1126                     (strcmp(direction, "up") == 0 ? D_UP :
1127                      D_DOWN))));
1128         tree_render();
1129     }
1130
1131
1132     // XXX: default reply for now, make this a better reply
1133     return sstrdup("{\"success\": true}");
1134 }
1135
1136 /*
1137  * Implementation of 'layout default|stacked|stacking|tabbed'.
1138  *
1139  */
1140 char *cmd_layout(Match *current_match, char *layout_str) {
1141     if (strcmp(layout_str, "stacking") == 0)
1142         layout_str = "stacked";
1143     DLOG("changing layout to %s\n", layout_str);
1144     owindow *current;
1145     int layout = (strcmp(layout_str, "default") == 0 ? L_DEFAULT :
1146                   (strcmp(layout_str, "stacked") == 0 ? L_STACKED :
1147                    L_TABBED));
1148
1149     /* check if the match is empty, not if the result is empty */
1150     if (match_is_empty(current_match))
1151         con_set_layout(focused->parent, layout);
1152     else {
1153         TAILQ_FOREACH(current, &owindows, owindows) {
1154             DLOG("matching: %p / %s\n", current->con, current->con->name);
1155             con_set_layout(current->con, layout);
1156         }
1157     }
1158
1159     tree_render();
1160
1161     // XXX: default reply for now, make this a better reply
1162     return sstrdup("{\"success\": true}");
1163 }
1164
1165 /*
1166  * Implementaiton of 'exit'.
1167  *
1168  */
1169 char *cmd_exit(Match *current_match) {
1170     LOG("Exiting due to user command.\n");
1171     exit(0);
1172
1173     /* unreached */
1174 }
1175
1176 /*
1177  * Implementaiton of 'reload'.
1178  *
1179  */
1180 char *cmd_reload(Match *current_match) {
1181     LOG("reloading\n");
1182     kill_configerror_nagbar(false);
1183     load_configuration(conn, NULL, true);
1184     x_set_i3_atoms();
1185     /* Send an IPC event just in case the ws names have changed */
1186     ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"reload\"}");
1187
1188     // XXX: default reply for now, make this a better reply
1189     return sstrdup("{\"success\": true}");
1190 }
1191
1192 /*
1193  * Implementaiton of 'restart'.
1194  *
1195  */
1196 char *cmd_restart(Match *current_match) {
1197     LOG("restarting i3\n");
1198     i3_restart(false);
1199
1200     // XXX: default reply for now, make this a better reply
1201     return sstrdup("{\"success\": true}");
1202 }
1203
1204 /*
1205  * Implementaiton of 'open'.
1206  *
1207  */
1208 char *cmd_open(Match *current_match) {
1209     LOG("opening new container\n");
1210     Con *con = tree_open_con(NULL, NULL);
1211     con_focus(con);
1212     char *json_output;
1213     sasprintf(&json_output, "{\"success\":true, \"id\":%ld}", (long int)con);
1214
1215     tree_render();
1216
1217     return json_output;
1218 }
1219
1220 /*
1221  * Implementation of 'focus output <output>'.
1222  *
1223  */
1224 char *cmd_focus_output(Match *current_match, char *name) {
1225     owindow *current;
1226
1227     DLOG("name = %s\n", name);
1228
1229     HANDLE_EMPTY_MATCH;
1230
1231     /* get the output */
1232     Output *current_output = NULL;
1233     Output *output;
1234
1235     TAILQ_FOREACH(current, &owindows, owindows)
1236         current_output = get_output_containing(current->con->rect.x, current->con->rect.y);
1237     assert(current_output != NULL);
1238
1239     output = get_output_from_string(current_output, name);
1240
1241     if (!output) {
1242         LOG("No such output found.\n");
1243         return sstrdup("{\"sucess\": false}");
1244     }
1245
1246     /* get visible workspace on output */
1247     Con *ws = NULL;
1248     GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
1249     if (!ws)
1250         return sstrdup("{\"sucess\": false}");
1251
1252     workspace_show(ws);
1253     tree_render();
1254
1255     // XXX: default reply for now, make this a better reply
1256     return sstrdup("{\"success\": true}");
1257 }
1258
1259 /*
1260  * Implementation of 'move scratchpad'.
1261  *
1262  */
1263 char *cmd_move_scratchpad(Match *current_match) {
1264     DLOG("should move window to scratchpad\n");
1265     owindow *current;
1266
1267     HANDLE_EMPTY_MATCH;
1268
1269     TAILQ_FOREACH(current, &owindows, owindows) {
1270         DLOG("matching: %p / %s\n", current->con, current->con->name);
1271         scratchpad_move(current->con);
1272     }
1273
1274     tree_render();
1275
1276     // XXX: default reply for now, make this a better reply
1277     return sstrdup("{\"success\": true}");
1278 }
1279
1280 /*
1281  * Implementation of 'scratchpad show'.
1282  *
1283  */
1284 char *cmd_scratchpad_show(Match *current_match) {
1285     DLOG("should show scratchpad window\n");
1286     owindow *current;
1287
1288     if (match_is_empty(current_match)) {
1289         scratchpad_show(NULL);
1290     } else {
1291         TAILQ_FOREACH(current, &owindows, owindows) {
1292             DLOG("matching: %p / %s\n", current->con, current->con->name);
1293             scratchpad_show(current->con);
1294         }
1295     }
1296
1297     tree_render();
1298
1299     // XXX: default reply for now, make this a better reply
1300     return sstrdup("{\"success\": true}");
1301 }