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         if (con_num_children(ws->parent) == 1) {
 791             LOG("Not moving workspace \"%s\", it is the only workspace on its output.\n", ws->name);
 792             continue;
 793         }
 794         bool workspace_was_visible = workspace_is_visible(ws);
 795         Con *old_content = ws->parent;
 796         con_detach(ws);
 797         if (workspace_was_visible) {
 798             /* The workspace which we just detached was visible, so focus
 799              * the next one in the focus-stack. */
 800             Con *focus_ws = TAILQ_FIRST(&(old_content->focus_head));
 801             LOG("workspace was visible, focusing %p / %s now\n", focus_ws, focus_ws->name);
 802             workspace_show(focus_ws);
 803         }
 804         con_attach(ws, content, false);
 805         ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"move\"}");
 806         if (workspace_was_visible) {
 807             /* Focus the moved workspace on the destination output. */
 808             workspace_show(ws);
 809         }
 810     }
 811
 812     tree_render();
 813
 814     // XXX: default reply for now, make this a better reply
 815     return sstrdup("{\"success\": true}");
 816 }
 817
 818 /*
 819  * Implementation of 'split v|h|vertical|horizontal'.
 820  *
 821  */
 822 char *cmd_split(Match *current_match, char *direction) {
 823     /* TODO: use matches */
 824     LOG("splitting in direction %c\n", direction[0]);
 825     tree_split(focused, (direction[0] == 'v' ? VERT : HORIZ));
 826
 827     tree_render();
 828
 829     // XXX: default reply for now, make this a better reply
 830     return sstrdup("{\"success\": true}");
 831 }
 832
 833 /*
 834  * Implementaiton of 'kill [window|client]'.
 835  *
 836  */
 837 char *cmd_kill(Match *current_match, char *kill_mode_str) {
 838     if (kill_mode_str == NULL)
 839         kill_mode_str = "window";
 840     owindow *current;
 841
 842     DLOG("kill_mode=%s\n", kill_mode_str);
 843
 844     int kill_mode;
 845     if (strcmp(kill_mode_str, "window") == 0)
 846         kill_mode = KILL_WINDOW;
 847     else if (strcmp(kill_mode_str, "client") == 0)
 848         kill_mode = KILL_CLIENT;
 849     else {
 850         ELOG("BUG: called with kill_mode=%s\n", kill_mode_str);
 851         return sstrdup("{\"sucess\": false}");
 852     }
 853
 854     /* check if the match is empty, not if the result is empty */
 855     if (match_is_empty(current_match))
 856         tree_close_con(kill_mode);
 857     else {
 858         TAILQ_FOREACH(current, &owindows, owindows) {
 859             DLOG("matching: %p / %s\n", current->con, current->con->name);
 860             tree_close(current->con, kill_mode, false, false);
 861         }
 862     }
 863
 864     tree_render();
 865
 866     // XXX: default reply for now, make this a better reply
 867     return sstrdup("{\"success\": true}");
 868 }
 869
 870 /*
 871  * Implementation of 'exec [--no-startup-id] <command>'.
 872  *
 873  */
 874 char *cmd_exec(Match *current_match, char *nosn, char *command) {
 875     bool no_startup_id = (nosn != NULL);
 876
 877     DLOG("should execute %s, no_startup_id = %d\n", command, no_startup_id);
 878     start_application(command, no_startup_id);
 879
 880     // XXX: default reply for now, make this a better reply
 881     return sstrdup("{\"success\": true}");
 882 }
 883
 884 /*
 885  * Implementation of 'focus left|right|up|down'.
 886  *
 887  */
 888 char *cmd_focus_direction(Match *current_match, char *direction) {
 889     if (focused &&
 890         focused->type != CT_WORKSPACE &&
 891         focused->fullscreen_mode != CF_NONE) {
 892         LOG("Cannot change focus while in fullscreen mode.\n");
 893         return sstrdup("{\"sucess\": false}");
 894     }
 895
 896     DLOG("direction = *%s*\n", direction);
 897
 898     if (strcmp(direction, "left") == 0)
 899         tree_next('p', HORIZ);
 900     else if (strcmp(direction, "right") == 0)
 901         tree_next('n', HORIZ);
 902     else if (strcmp(direction, "up") == 0)
 903         tree_next('p', VERT);
 904     else if (strcmp(direction, "down") == 0)
 905         tree_next('n', VERT);
 906     else {
 907         ELOG("Invalid focus direction (%s)\n", direction);
 908         return sstrdup("{\"sucess\": false}");
 909     }
 910
 911     tree_render();
 912
 913     // XXX: default reply for now, make this a better reply
 914     return sstrdup("{\"success\": true}");
 915 }
 916
 917 /*
 918  * Implementation of 'focus tiling|floating|mode_toggle'.
 919  *
 920  */
 921 char *cmd_focus_window_mode(Match *current_match, char *window_mode) {
 922     if (focused &&
 923         focused->type != CT_WORKSPACE &&
 924         focused->fullscreen_mode != CF_NONE) {
 925         LOG("Cannot change focus while in fullscreen mode.\n");
 926         return sstrdup("{\"sucess\": false}");
 927     }
 928
 929     DLOG("window_mode = %s\n", window_mode);
 930
 931     Con *ws = con_get_workspace(focused);
 932     Con *current;
 933     if (ws != NULL) {
 934         if (strcmp(window_mode, "mode_toggle") == 0) {
 935             current = TAILQ_FIRST(&(ws->focus_head));
 936             if (current != NULL && current->type == CT_FLOATING_CON)
 937                 window_mode = "tiling";
 938             else window_mode = "floating";
 939         }
 940         TAILQ_FOREACH(current, &(ws->focus_head), focused) {
 941             if ((strcmp(window_mode, "floating") == 0 && current->type != CT_FLOATING_CON) ||
 942                 (strcmp(window_mode, "tiling") == 0 && current->type == CT_FLOATING_CON))
 943                 continue;
 944
 945             con_focus(con_descend_focused(current));
 946             break;
 947         }
 948     }
 949
 950     tree_render();
 951
 952     // XXX: default reply for now, make this a better reply
 953     return sstrdup("{\"success\": true}");
 954 }
 955
 956 /*
 957  * Implementation of 'focus parent|child'.
 958  *
 959  */
 960 char *cmd_focus_level(Match *current_match, char *level) {
 961     if (focused &&
 962         focused->type != CT_WORKSPACE &&
 963         focused->fullscreen_mode != CF_NONE) {
 964         LOG("Cannot change focus while in fullscreen mode.\n");
 965         return sstrdup("{\"sucess\": false}");
 966     }
 967
 968     DLOG("level = %s\n", level);
 969
 970     if (strcmp(level, "parent") == 0)
 971         level_up();
 972     else level_down();
 973
 974     tree_render();
 975
 976     // XXX: default reply for now, make this a better reply
 977     return sstrdup("{\"success\": true}");
 978 }
 979
 980 /*
 981  * Implementation of 'focus'.
 982  *
 983  */
 984 char *cmd_focus(Match *current_match) {
 985     DLOG("current_match = %p\n", current_match);
 986     if (focused &&
 987         focused->type != CT_WORKSPACE &&
 988         focused->fullscreen_mode != CF_NONE) {
 989         LOG("Cannot change focus while in fullscreen mode.\n");
 990         return sstrdup("{\"sucess\": false}");
 991     }
 992
 993     owindow *current;
 994
 995     if (match_is_empty(current_match)) {
 996         ELOG("You have to specify which window/container should be focused.\n");
 997         ELOG("Example: [class=\"urxvt\" title=\"irssi\"] focus\n");
 998
 999         char *json_output;
1000         sasprintf(&json_output, "{\"success\":false, \"error\":\"You have to "
1001                   "specify which window/container should be focused\"}");
1002         return json_output;
1003     }
1004
1005     int count = 0;
1006     TAILQ_FOREACH(current, &owindows, owindows) {
1007         Con *ws = con_get_workspace(current->con);
1008         /* If no workspace could be found, this was a dock window.
1009          * Just skip it, you cannot focus dock windows. */
1010         if (!ws)
1011             continue;
1012
1013         /* If the container is not on the current workspace,
1014          * workspace_show() will switch to a different workspace and (if
1015          * enabled) trigger a mouse pointer warp to the currently focused
1016          * container (!) on the target workspace.
1017          *
1018          * Therefore, before calling workspace_show(), we make sure that
1019          * 'current' will be focused on the workspace. However, we cannot
1020          * just con_focus(current) because then the pointer will not be
1021          * warped at all (the code thinks we are already there).
1022          *
1023          * So we focus 'current' to make it the currently focused window of
1024          * the target workspace, then revert focus. */
1025         Con *currently_focused = focused;
1026         con_focus(current->con);
1027         con_focus(currently_focused);
1028
1029         /* Now switch to the workspace, then focus */
1030         workspace_show(ws);
1031         LOG("focusing %p / %s\n", current->con, current->con->name);
1032         con_focus(current->con);
1033         count++;
1034     }
1035
1036     if (count > 1)
1037         LOG("WARNING: Your criteria for the focus command matches %d containers, "
1038             "while only exactly one container can be focused at a time.\n", count);
1039
1040     tree_render();
1041
1042     // XXX: default reply for now, make this a better reply
1043     return sstrdup("{\"success\": true}");
1044 }
1045
1046 /*
1047  * Implementation of 'fullscreen [global]'.
1048  *
1049  */
1050 char *cmd_fullscreen(Match *current_match, char *fullscreen_mode) {
1051     if (fullscreen_mode == NULL)
1052         fullscreen_mode = "output";
1053     DLOG("toggling fullscreen, mode = %s\n", fullscreen_mode);
1054     owindow *current;
1055
1056     HANDLE_EMPTY_MATCH;
1057
1058     TAILQ_FOREACH(current, &owindows, owindows) {
1059         printf("matching: %p / %s\n", current->con, current->con->name);
1060         con_toggle_fullscreen(current->con, (strcmp(fullscreen_mode, "global") == 0 ? CF_GLOBAL : CF_OUTPUT));
1061     }
1062
1063     tree_render();
1064
1065     // XXX: default reply for now, make this a better reply
1066     return sstrdup("{\"success\": true}");
1067 }
1068
1069 /*
1070  * Implementation of 'move <direction> [<pixels> [px]]'.
1071  *
1072  */
1073 char *cmd_move_direction(Match *current_match, char *direction, char *move_px) {
1074     // 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
1075     int px = atoi(move_px);
1076
1077     /* TODO: make 'move' work with criteria. */
1078     DLOG("moving in direction %s, px %s\n", direction, move_px);
1079     if (con_is_floating(focused)) {
1080         DLOG("floating move with %d pixels\n", px);
1081         Rect newrect = focused->parent->rect;
1082         if (strcmp(direction, "left") == 0) {
1083             newrect.x -= px;
1084         } else if (strcmp(direction, "right") == 0) {
1085             newrect.x += px;
1086         } else if (strcmp(direction, "up") == 0) {
1087             newrect.y -= px;
1088         } else if (strcmp(direction, "down") == 0) {
1089             newrect.y += px;
1090         }
1091         floating_reposition(focused->parent, newrect);
1092     } else {
1093         tree_move((strcmp(direction, "right") == 0 ? D_RIGHT :
1094                    (strcmp(direction, "left") == 0 ? D_LEFT :
1095                     (strcmp(direction, "up") == 0 ? D_UP :
1096                      D_DOWN))));
1097         tree_render();
1098     }
1099
1100
1101     // XXX: default reply for now, make this a better reply
1102     return sstrdup("{\"success\": true}");
1103 }
1104
1105 /*
1106  * Implementation of 'layout default|stacked|stacking|tabbed'.
1107  *
1108  */
1109 char *cmd_layout(Match *current_match, char *layout_str) {
1110     if (strcmp(layout_str, "stacking") == 0)
1111         layout_str = "stacked";
1112     DLOG("changing layout to %s\n", layout_str);
1113     owindow *current;
1114     int layout = (strcmp(layout_str, "default") == 0 ? L_DEFAULT :
1115                   (strcmp(layout_str, "stacked") == 0 ? L_STACKED :
1116                    L_TABBED));
1117
1118     /* check if the match is empty, not if the result is empty */
1119     if (match_is_empty(current_match))
1120         con_set_layout(focused->parent, layout);
1121     else {
1122         TAILQ_FOREACH(current, &owindows, owindows) {
1123             DLOG("matching: %p / %s\n", current->con, current->con->name);
1124             con_set_layout(current->con, layout);
1125         }
1126     }
1127
1128     tree_render();
1129
1130     // XXX: default reply for now, make this a better reply
1131     return sstrdup("{\"success\": true}");
1132 }
1133
1134 /*
1135  * Implementaiton of 'exit'.
1136  *
1137  */
1138 char *cmd_exit(Match *current_match) {
1139     LOG("Exiting due to user command.\n");
1140     exit(0);
1141
1142     /* unreached */
1143 }
1144
1145 /*
1146  * Implementaiton of 'reload'.
1147  *
1148  */
1149 char *cmd_reload(Match *current_match) {
1150     LOG("reloading\n");
1151     kill_configerror_nagbar(false);
1152     load_configuration(conn, NULL, true);
1153     x_set_i3_atoms();
1154     /* Send an IPC event just in case the ws names have changed */
1155     ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"reload\"}");
1156
1157     // XXX: default reply for now, make this a better reply
1158     return sstrdup("{\"success\": true}");
1159 }
1160
1161 /*
1162  * Implementaiton of 'restart'.
1163  *
1164  */
1165 char *cmd_restart(Match *current_match) {
1166     LOG("restarting i3\n");
1167     i3_restart(false);
1168
1169     // XXX: default reply for now, make this a better reply
1170     return sstrdup("{\"success\": true}");
1171 }
1172
1173 /*
1174  * Implementaiton of 'open'.
1175  *
1176  */
1177 char *cmd_open(Match *current_match) {
1178     LOG("opening new container\n");
1179     Con *con = tree_open_con(NULL, NULL);
1180     con_focus(con);
1181     char *json_output;
1182     sasprintf(&json_output, "{\"success\":true, \"id\":%ld}", (long int)con);
1183
1184     tree_render();
1185
1186     return json_output;
1187 }
1188
1189 /*
1190  * Implementation of 'focus output <output>'.
1191  *
1192  */
1193 char *cmd_focus_output(Match *current_match, char *name) {
1194     owindow *current;
1195
1196     DLOG("name = %s\n", name);
1197
1198     HANDLE_EMPTY_MATCH;
1199
1200     /* get the output */
1201     Output *current_output = NULL;
1202     Output *output;
1203
1204     TAILQ_FOREACH(current, &owindows, owindows)
1205         current_output = get_output_containing(current->con->rect.x, current->con->rect.y);
1206     assert(current_output != NULL);
1207
1208     output = get_output_from_string(current_output, name);
1209
1210     if (!output) {
1211         LOG("No such output found.\n");
1212         return sstrdup("{\"sucess\": false}");
1213     }
1214
1215     /* get visible workspace on output */
1216     Con *ws = NULL;
1217     GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
1218     if (!ws)
1219         return sstrdup("{\"sucess\": false}");
1220
1221     workspace_show(ws);
1222     tree_render();
1223
1224     // XXX: default reply for now, make this a better reply
1225     return sstrdup("{\"success\": true}");
1226 }
1227
1228 /*
1229  * Implementation of 'move scratchpad'.
1230  *
1231  */
1232 char *cmd_move_scratchpad(Match *current_match) {
1233     DLOG("should move window to scratchpad\n");
1234     owindow *current;
1235
1236     HANDLE_EMPTY_MATCH;
1237
1238     TAILQ_FOREACH(current, &owindows, owindows) {
1239         DLOG("matching: %p / %s\n", current->con, current->con->name);
1240         scratchpad_move(current->con);
1241     }
1242
1243     tree_render();
1244
1245     // XXX: default reply for now, make this a better reply
1246     return sstrdup("{\"success\": true}");
1247 }
1248
1249 /*
1250  * Implementation of 'scratchpad show'.
1251  *
1252  */
1253 char *cmd_scratchpad_show(Match *current_match) {
1254     DLOG("should show scratchpad window\n");
1255     owindow *current;
1256
1257     if (match_is_empty(current_match)) {
1258         scratchpad_show(NULL);
1259     } else {
1260         TAILQ_FOREACH(current, &owindows, owindows) {
1261             DLOG("matching: %p / %s\n", current->con, current->con->name);
1262             scratchpad_show(current->con);
1263         }
1264     }
1265
1266     tree_render();
1267
1268     // XXX: default reply for now, make this a better reply
1269     return sstrdup("{\"success\": true}");
1270 }