]> git.sur5r.net Git - i3/i3/blob - src/commands.c
Merge branch 'master' into next
[i3/i3] / 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 // Macros to make the YAJL API a bit easier to use.
16 #define y(x, ...) yajl_gen_ ## x (cmd_output->json_gen, ##__VA_ARGS__)
17 #define ystr(str) yajl_gen_string(cmd_output->json_gen, (unsigned char*)str, strlen(str))
18 #define ysuccess(success) do { \
19     y(map_open); \
20     ystr("success"); \
21     y(bool, success); \
22     y(map_close); \
23 } while (0)
24
25 /** When the command did not include match criteria (!), we use the currently
26  * focused container. Do not confuse this case with a command which included
27  * criteria but which did not match any windows. This macro has to be called in
28  * every command.
29  */
30 #define HANDLE_EMPTY_MATCH do { \
31     if (match_is_empty(current_match)) { \
32         owindow *ow = smalloc(sizeof(owindow)); \
33         ow->con = focused; \
34         TAILQ_INIT(&owindows); \
35         TAILQ_INSERT_TAIL(&owindows, ow, owindows); \
36     } \
37 } while (0)
38
39 static owindows_head owindows;
40
41 /*
42  * Returns true if a is definitely greater than b (using the given epsilon)
43  *
44  */
45 static bool definitelyGreaterThan(float a, float b, float epsilon) {
46     return (a - b) > ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
47 }
48
49 /*
50  * Returns an 'output' corresponding to one of left/right/down/up or a specific
51  * output name.
52  *
53  */
54 static Output *get_output_from_string(Output *current_output, const char *output_str) {
55     Output *output;
56
57     if (strcasecmp(output_str, "left") == 0) {
58         output = get_output_next(D_LEFT, current_output);
59         if (!output)
60             output = get_output_most(D_RIGHT, current_output);
61     } else if (strcasecmp(output_str, "right") == 0) {
62         output = get_output_next(D_RIGHT, current_output);
63         if (!output)
64             output = get_output_most(D_LEFT, current_output);
65     } else if (strcasecmp(output_str, "up") == 0) {
66         output = get_output_next(D_UP, current_output);
67         if (!output)
68             output = get_output_most(D_DOWN, current_output);
69     } else if (strcasecmp(output_str, "down") == 0) {
70         output = get_output_next(D_DOWN, current_output);
71         if (!output)
72             output = get_output_most(D_UP, current_output);
73     } else output = get_output_by_name(output_str);
74
75     return output;
76 }
77
78 /*
79  * Checks whether we switched to a new workspace and returns false in that case,
80  * signaling that further workspace switching should be done by the calling function
81  * If not, calls workspace_back_and_forth() if workspace_auto_back_and_forth is set
82  * and return true, signaling that no further workspace switching should occur in the calling function.
83  *
84  */
85 static bool maybe_back_and_forth(struct CommandResult *cmd_output, char *name) {
86     Con *ws = con_get_workspace(focused);
87
88     /* If we switched to a different workspace, do nothing */
89     if (strcmp(ws->name, name) != 0)
90         return false;
91
92     DLOG("This workspace is already focused.\n");
93     if (config.workspace_auto_back_and_forth) {
94         workspace_back_and_forth();
95         cmd_output->needs_tree_render = true;
96     }
97     return true;
98 }
99
100 // This code is commented out because we might recycle it for popping up error
101 // messages on parser errors.
102 #if 0
103 static pid_t migration_pid = -1;
104
105 /*
106  * Handler which will be called when we get a SIGCHLD for the nagbar, meaning
107  * it exited (or could not be started, depending on the exit code).
108  *
109  */
110 static void nagbar_exited(EV_P_ ev_child *watcher, int revents) {
111     ev_child_stop(EV_A_ watcher);
112     if (!WIFEXITED(watcher->rstatus)) {
113         fprintf(stderr, "ERROR: i3-nagbar did not exit normally.\n");
114         return;
115     }
116
117     int exitcode = WEXITSTATUS(watcher->rstatus);
118     printf("i3-nagbar process exited with status %d\n", exitcode);
119     if (exitcode == 2) {
120         fprintf(stderr, "ERROR: i3-nagbar could not be found. Is it correctly installed on your system?\n");
121     }
122
123     migration_pid = -1;
124 }
125
126 /* We need ev >= 4 for the following code. Since it is not *that* important (it
127  * only makes sure that there are no i3-nagbar instances left behind) we still
128  * support old systems with libev 3. */
129 #if EV_VERSION_MAJOR >= 4
130 /*
131  * Cleanup handler. Will be called when i3 exits. Kills i3-nagbar with signal
132  * SIGKILL (9) to make sure there are no left-over i3-nagbar processes.
133  *
134  */
135 static void nagbar_cleanup(EV_P_ ev_cleanup *watcher, int revent) {
136     if (migration_pid != -1) {
137         LOG("Sending SIGKILL (9) to i3-nagbar with PID %d\n", migration_pid);
138         kill(migration_pid, SIGKILL);
139     }
140 }
141 #endif
142
143 void cmd_MIGRATION_start_nagbar(void) {
144     if (migration_pid != -1) {
145         fprintf(stderr, "i3-nagbar already running.\n");
146         return;
147     }
148     fprintf(stderr, "Starting i3-nagbar, command parsing differs from expected output.\n");
149     ELOG("Please report this on IRC or in the bugtracker. Make sure to include the full debug level logfile:\n");
150     ELOG("i3-dump-log | gzip -9c > /tmp/i3.log.gz\n");
151     ELOG("FYI: Your i3 version is " I3_VERSION "\n");
152     migration_pid = fork();
153     if (migration_pid == -1) {
154         warn("Could not fork()");
155         return;
156     }
157
158     /* child */
159     if (migration_pid == 0) {
160         char *pageraction;
161         sasprintf(&pageraction, "i3-sensible-terminal -e i3-sensible-pager \"%s\"", errorfilename);
162         char *argv[] = {
163             NULL, /* will be replaced by the executable path */
164             "-t",
165             "error",
166             "-m",
167             "You found a parsing error. Please, please, please, report it!",
168             "-b",
169             "show errors",
170             pageraction,
171             NULL
172         };
173         exec_i3_utility("i3-nagbar", argv);
174     }
175
176     /* parent */
177     /* install a child watcher */
178     ev_child *child = smalloc(sizeof(ev_child));
179     ev_child_init(child, &nagbar_exited, migration_pid, 0);
180     ev_child_start(main_loop, child);
181
182 /* We need ev >= 4 for the following code. Since it is not *that* important (it
183  * only makes sure that there are no i3-nagbar instances left behind) we still
184  * support old systems with libev 3. */
185 #if EV_VERSION_MAJOR >= 4
186     /* install a cleanup watcher (will be called when i3 exits and i3-nagbar is
187      * still running) */
188     ev_cleanup *cleanup = smalloc(sizeof(ev_cleanup));
189     ev_cleanup_init(cleanup, nagbar_cleanup);
190     ev_cleanup_start(main_loop, cleanup);
191 #endif
192 }
193
194 #endif
195
196 /*******************************************************************************
197  * Criteria functions.
198  ******************************************************************************/
199
200 /*
201  * Initializes the specified 'Match' data structure and the initial state of
202  * commands.c for matching target windows of a command.
203  *
204  */
205 void cmd_criteria_init(I3_CMD) {
206     Con *con;
207     owindow *ow;
208
209     DLOG("Initializing criteria, current_match = %p\n", current_match);
210     match_init(current_match);
211     while (!TAILQ_EMPTY(&owindows)) {
212         ow = TAILQ_FIRST(&owindows);
213         TAILQ_REMOVE(&owindows, ow, owindows);
214         free(ow);
215     }
216     TAILQ_INIT(&owindows);
217     /* copy all_cons */
218     TAILQ_FOREACH(con, &all_cons, all_cons) {
219         ow = smalloc(sizeof(owindow));
220         ow->con = con;
221         TAILQ_INSERT_TAIL(&owindows, ow, owindows);
222     }
223 }
224
225 /*
226  * A match specification just finished (the closing square bracket was found),
227  * so we filter the list of owindows.
228  *
229  */
230 void cmd_criteria_match_windows(I3_CMD) {
231     owindow *next, *current;
232
233     DLOG("match specification finished, matching...\n");
234     /* copy the old list head to iterate through it and start with a fresh
235      * list which will contain only matching windows */
236     struct owindows_head old = owindows;
237     TAILQ_INIT(&owindows);
238     for (next = TAILQ_FIRST(&old); next != TAILQ_END(&old);) {
239         /* make a copy of the next pointer and advance the pointer to the
240          * next element as we are going to invalidate the element’s
241          * next/prev pointers by calling TAILQ_INSERT_TAIL later */
242         current = next;
243         next = TAILQ_NEXT(next, owindows);
244
245         DLOG("checking if con %p / %s matches\n", current->con, current->con->name);
246         if (current_match->con_id != NULL) {
247             if (current_match->con_id == current->con) {
248                 DLOG("matches container!\n");
249                 TAILQ_INSERT_TAIL(&owindows, current, owindows);
250             }
251         } else if (current_match->mark != NULL && current->con->mark != NULL &&
252                    regex_matches(current_match->mark, current->con->mark)) {
253             DLOG("match by mark\n");
254             TAILQ_INSERT_TAIL(&owindows, current, owindows);
255         } else {
256             if (current->con->window == NULL)
257                 continue;
258             if (match_matches_window(current_match, current->con->window)) {
259                 DLOG("matches window!\n");
260                 TAILQ_INSERT_TAIL(&owindows, current, owindows);
261             } else {
262                 DLOG("doesnt match\n");
263                 free(current);
264             }
265         }
266     }
267
268     TAILQ_FOREACH(current, &owindows, owindows) {
269         DLOG("matching: %p / %s\n", current->con, current->con->name);
270     }
271 }
272
273 /*
274  * Interprets a ctype=cvalue pair and adds it to the current match
275  * specification.
276  *
277  */
278 void cmd_criteria_add(I3_CMD, char *ctype, char *cvalue) {
279     DLOG("ctype=*%s*, cvalue=*%s*\n", ctype, cvalue);
280
281     if (strcmp(ctype, "class") == 0) {
282         current_match->class = regex_new(cvalue);
283         return;
284     }
285
286     if (strcmp(ctype, "instance") == 0) {
287         current_match->instance = regex_new(cvalue);
288         return;
289     }
290
291     if (strcmp(ctype, "window_role") == 0) {
292         current_match->role = regex_new(cvalue);
293         return;
294     }
295
296     if (strcmp(ctype, "con_id") == 0) {
297         char *end;
298         long parsed = strtol(cvalue, &end, 10);
299         if (parsed == LONG_MIN ||
300             parsed == LONG_MAX ||
301             parsed < 0 ||
302             (end && *end != '\0')) {
303             ELOG("Could not parse con id \"%s\"\n", cvalue);
304         } else {
305             current_match->con_id = (Con*)parsed;
306             printf("id as int = %p\n", current_match->con_id);
307         }
308         return;
309     }
310
311     if (strcmp(ctype, "id") == 0) {
312         char *end;
313         long parsed = strtol(cvalue, &end, 10);
314         if (parsed == LONG_MIN ||
315             parsed == LONG_MAX ||
316             parsed < 0 ||
317             (end && *end != '\0')) {
318             ELOG("Could not parse window id \"%s\"\n", cvalue);
319         } else {
320             current_match->id = parsed;
321             printf("window id as int = %d\n", current_match->id);
322         }
323         return;
324     }
325
326     if (strcmp(ctype, "con_mark") == 0) {
327         current_match->mark = regex_new(cvalue);
328         return;
329     }
330
331     if (strcmp(ctype, "title") == 0) {
332         current_match->title = regex_new(cvalue);
333         return;
334     }
335
336     if (strcmp(ctype, "urgent") == 0) {
337         if (strcasecmp(cvalue, "latest") == 0 ||
338             strcasecmp(cvalue, "newest") == 0 ||
339             strcasecmp(cvalue, "recent") == 0 ||
340             strcasecmp(cvalue, "last") == 0) {
341             current_match->urgent = U_LATEST;
342         } else if (strcasecmp(cvalue, "oldest") == 0 ||
343                    strcasecmp(cvalue, "first") == 0) {
344             current_match->urgent = U_OLDEST;
345         }
346         return;
347     }
348
349     ELOG("Unknown criterion: %s\n", ctype);
350 }
351
352 /*
353  * Implementation of 'move [window|container] [to] workspace
354  * next|prev|next_on_output|prev_on_output|current'.
355  *
356  */
357 void cmd_move_con_to_workspace(I3_CMD, char *which) {
358     owindow *current;
359
360     DLOG("which=%s\n", which);
361
362     /* We have nothing to move:
363      *  when criteria was specified but didn't match any window or
364      *  when criteria wasn't specified and we don't have any window focused. */
365     if ((!match_is_empty(current_match) && TAILQ_EMPTY(&owindows)) ||
366         (match_is_empty(current_match) && focused->type == CT_WORKSPACE)) {
367         ysuccess(false);
368         return;
369     }
370
371     HANDLE_EMPTY_MATCH;
372
373     /* get the workspace */
374     Con *ws;
375     if (strcmp(which, "next") == 0)
376         ws = workspace_next();
377     else if (strcmp(which, "prev") == 0)
378         ws = workspace_prev();
379     else if (strcmp(which, "next_on_output") == 0)
380         ws = workspace_next_on_output();
381     else if (strcmp(which, "prev_on_output") == 0)
382         ws = workspace_prev_on_output();
383     else if (strcmp(which, "current") == 0)
384         ws = con_get_workspace(focused);
385     else {
386         ELOG("BUG: called with which=%s\n", which);
387         ysuccess(false);
388         return;
389     }
390
391     TAILQ_FOREACH(current, &owindows, owindows) {
392         DLOG("matching: %p / %s\n", current->con, current->con->name);
393         con_move_to_workspace(current->con, ws, true, false);
394     }
395
396     cmd_output->needs_tree_render = true;
397     // XXX: default reply for now, make this a better reply
398     ysuccess(true);
399 }
400
401 /*
402  * Implementation of 'move [window|container] [to] workspace <name>'.
403  *
404  */
405 void cmd_move_con_to_workspace_name(I3_CMD, char *name) {
406     if (strncasecmp(name, "__i3_", strlen("__i3_")) == 0) {
407         LOG("You cannot switch to the i3 internal workspaces.\n");
408         ysuccess(false);
409         return;
410     }
411
412     owindow *current;
413
414     /* We have nothing to move:
415      *  when criteria was specified but didn't match any window or
416      *  when criteria wasn't specified and we don't have any window focused. */
417     if ((!match_is_empty(current_match) && TAILQ_EMPTY(&owindows)) ||
418         (match_is_empty(current_match) && focused->type == CT_WORKSPACE)) {
419         ysuccess(false);
420         return;
421     }
422
423     LOG("should move window to workspace %s\n", name);
424     /* get the workspace */
425     Con *ws = workspace_get(name, NULL);
426
427     HANDLE_EMPTY_MATCH;
428
429     TAILQ_FOREACH(current, &owindows, owindows) {
430         DLOG("matching: %p / %s\n", current->con, current->con->name);
431         con_move_to_workspace(current->con, ws, true, false);
432     }
433
434     cmd_output->needs_tree_render = true;
435     // XXX: default reply for now, make this a better reply
436     ysuccess(true);
437 }
438
439 /*
440  * Implementation of 'move [window|container] [to] workspace number <number>'.
441  *
442  */
443 void cmd_move_con_to_workspace_number(I3_CMD, char *which) {
444     owindow *current;
445
446     /* We have nothing to move:
447      *  when criteria was specified but didn't match any window or
448      *  when criteria wasn't specified and we don't have any window focused. */
449     if ((!match_is_empty(current_match) && TAILQ_EMPTY(&owindows)) ||
450         (match_is_empty(current_match) && focused->type == CT_WORKSPACE)) {
451         ysuccess(false);
452         return;
453     }
454
455     LOG("should move window to workspace with number %d\n", which);
456     /* get the workspace */
457     Con *output, *workspace = NULL;
458
459     char *endptr = NULL;
460     long parsed_num = strtol(which, &endptr, 10);
461     if (parsed_num == LONG_MIN ||
462         parsed_num == LONG_MAX ||
463         parsed_num < 0 ||
464         *endptr != '\0') {
465         LOG("Could not parse \"%s\" as a number.\n", which);
466         y(map_open);
467         ystr("success");
468         y(bool, false);
469         ystr("error");
470         // TODO: better error message
471         ystr("Could not parse number");
472         y(map_close);
473         return;
474     }
475
476     TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
477         GREP_FIRST(workspace, output_get_content(output),
478             child->num == parsed_num);
479
480     if (!workspace) {
481         y(map_open);
482         ystr("success");
483         y(bool, false);
484         ystr("error");
485         // TODO: better error message
486         ystr("No such workspace");
487         y(map_close);
488         return;
489     }
490
491     HANDLE_EMPTY_MATCH;
492
493     TAILQ_FOREACH(current, &owindows, owindows) {
494         DLOG("matching: %p / %s\n", current->con, current->con->name);
495         con_move_to_workspace(current->con, workspace, true, false);
496     }
497
498     cmd_output->needs_tree_render = true;
499     // XXX: default reply for now, make this a better reply
500     ysuccess(true);
501 }
502
503 static void cmd_resize_floating(I3_CMD, char *way, char *direction, Con *floating_con, int px) {
504     LOG("floating resize\n");
505     if (strcmp(direction, "up") == 0) {
506         floating_con->rect.y -= px;
507         floating_con->rect.height += px;
508     } else if (strcmp(direction, "down") == 0) {
509         floating_con->rect.height += px;
510     } else if (strcmp(direction, "left") == 0) {
511         floating_con->rect.x -= px;
512         floating_con->rect.width += px;
513     } else {
514         floating_con->rect.width += px;
515     }
516 }
517
518 static bool cmd_resize_tiling_direction(I3_CMD, char *way, char *direction, int ppt) {
519     LOG("tiling resize\n");
520     /* get the appropriate current container (skip stacked/tabbed cons) */
521     Con *current = focused;
522     Con *other = NULL;
523     double percentage = 0;
524     while (current->parent->layout == L_STACKED ||
525            current->parent->layout == L_TABBED)
526         current = current->parent;
527
528     /* Then further go up until we find one with the matching orientation. */
529     orientation_t search_orientation =
530         (strcmp(direction, "left") == 0 || strcmp(direction, "right") == 0 ? HORIZ : VERT);
531
532     do {
533         if (con_orientation(current->parent) != search_orientation) {
534             current = current->parent;
535             continue;
536         }
537
538         /* get the default percentage */
539         int children = con_num_children(current->parent);
540         LOG("ins. %d children\n", children);
541         percentage = 1.0 / children;
542         LOG("default percentage = %f\n", percentage);
543
544         orientation_t orientation = con_orientation(current->parent);
545
546         if ((orientation == HORIZ &&
547              (strcmp(direction, "up") == 0 || strcmp(direction, "down") == 0)) ||
548             (orientation == VERT &&
549              (strcmp(direction, "left") == 0 || strcmp(direction, "right") == 0))) {
550             LOG("You cannot resize in that direction. Your focus is in a %s split container currently.\n",
551                 (orientation == HORIZ ? "horizontal" : "vertical"));
552             ysuccess(false);
553             return false;
554         }
555
556         if (strcmp(direction, "up") == 0 || strcmp(direction, "left") == 0) {
557             other = TAILQ_PREV(current, nodes_head, nodes);
558         } else {
559             other = TAILQ_NEXT(current, nodes);
560         }
561         if (other == TAILQ_END(workspaces)) {
562             LOG("No other container in this direction found, trying to look further up in the tree...\n");
563             current = current->parent;
564             continue;
565         }
566         break;
567     } while (current->type != CT_WORKSPACE &&
568              current->type != CT_FLOATING_CON);
569
570     if (other == NULL) {
571         LOG("No other container in this direction found, trying to look further up in the tree...\n");
572         ysuccess(false);
573         return false;
574     }
575
576     LOG("other->percent = %f\n", other->percent);
577     LOG("current->percent before = %f\n", current->percent);
578     if (current->percent == 0.0)
579         current->percent = percentage;
580     if (other->percent == 0.0)
581         other->percent = percentage;
582     double new_current_percent = current->percent + ((double)ppt / 100.0);
583     double new_other_percent = other->percent - ((double)ppt / 100.0);
584     LOG("new_current_percent = %f\n", new_current_percent);
585     LOG("new_other_percent = %f\n", new_other_percent);
586     /* Ensure that the new percentages are positive and greater than
587      * 0.05 to have a reasonable minimum size. */
588     if (definitelyGreaterThan(new_current_percent, 0.05, DBL_EPSILON) &&
589         definitelyGreaterThan(new_other_percent, 0.05, DBL_EPSILON)) {
590         current->percent += ((double)ppt / 100.0);
591         other->percent -= ((double)ppt / 100.0);
592         LOG("current->percent after = %f\n", current->percent);
593         LOG("other->percent after = %f\n", other->percent);
594     } else {
595         LOG("Not resizing, already at minimum size\n");
596     }
597
598     return true;
599 }
600
601 static bool cmd_resize_tiling_width_height(I3_CMD, char *way, char *direction, int ppt) {
602     LOG("width/height resize\n");
603     /* get the appropriate current container (skip stacked/tabbed cons) */
604     Con *current = focused;
605     while (current->parent->layout == L_STACKED ||
606            current->parent->layout == L_TABBED)
607         current = current->parent;
608
609     /* Then further go up until we find one with the matching orientation. */
610     orientation_t search_orientation =
611         (strcmp(direction, "width") == 0 ? HORIZ : VERT);
612
613     while (current->type != CT_WORKSPACE &&
614            current->type != CT_FLOATING_CON &&
615            con_orientation(current->parent) != search_orientation)
616         current = current->parent;
617
618     /* get the default percentage */
619     int children = con_num_children(current->parent);
620     LOG("ins. %d children\n", children);
621     double percentage = 1.0 / children;
622     LOG("default percentage = %f\n", percentage);
623
624     orientation_t orientation = con_orientation(current->parent);
625
626     if ((orientation == HORIZ &&
627          strcmp(direction, "height") == 0) ||
628         (orientation == VERT &&
629          strcmp(direction, "width") == 0)) {
630         LOG("You cannot resize in that direction. Your focus is in a %s split container currently.\n",
631             (orientation == HORIZ ? "horizontal" : "vertical"));
632         ysuccess(false);
633         return false;
634     }
635
636     if (children == 1) {
637         LOG("This is the only container, cannot resize.\n");
638         ysuccess(false);
639         return false;
640     }
641
642     /* Ensure all the other children have a percentage set. */
643     Con *child;
644     TAILQ_FOREACH(child, &(current->parent->nodes_head), nodes) {
645         LOG("child->percent = %f (child %p)\n", child->percent, child);
646         if (child->percent == 0.0)
647             child->percent = percentage;
648     }
649
650     double new_current_percent = current->percent + ((double)ppt / 100.0);
651     double subtract_percent = ((double)ppt / 100.0) / (children - 1);
652     LOG("new_current_percent = %f\n", new_current_percent);
653     LOG("subtract_percent = %f\n", subtract_percent);
654     /* Ensure that the new percentages are positive and greater than
655      * 0.05 to have a reasonable minimum size. */
656     TAILQ_FOREACH(child, &(current->parent->nodes_head), nodes) {
657         if (child == current)
658             continue;
659         if (!definitelyGreaterThan(child->percent - subtract_percent, 0.05, DBL_EPSILON)) {
660             LOG("Not resizing, already at minimum size (child %p would end up with a size of %.f\n", child, child->percent - subtract_percent);
661             ysuccess(false);
662             return false;
663         }
664     }
665     if (!definitelyGreaterThan(new_current_percent, 0.05, DBL_EPSILON)) {
666         LOG("Not resizing, already at minimum size\n");
667         ysuccess(false);
668         return false;
669     }
670
671     current->percent += ((double)ppt / 100.0);
672     LOG("current->percent after = %f\n", current->percent);
673
674     TAILQ_FOREACH(child, &(current->parent->nodes_head), nodes) {
675         if (child == current)
676             continue;
677         child->percent -= subtract_percent;
678         LOG("child->percent after (%p) = %f\n", child, child->percent);
679     }
680
681     return true;
682 }
683
684 /*
685  * Implementation of 'resize grow|shrink <direction> [<px> px] [or <ppt> ppt]'.
686  *
687  */
688 void cmd_resize(I3_CMD, char *way, char *direction, char *resize_px, char *resize_ppt) {
689     /* resize <grow|shrink> <direction> [<px> px] [or <ppt> ppt] */
690     DLOG("resizing in way %s, direction %s, px %s or ppt %s\n", way, direction, resize_px, resize_ppt);
691     // 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
692     int px = atoi(resize_px);
693     int ppt = atoi(resize_ppt);
694     if (strcmp(way, "shrink") == 0) {
695         px *= -1;
696         ppt *= -1;
697     }
698
699     Con *floating_con;
700     if ((floating_con = con_inside_floating(focused))) {
701         cmd_resize_floating(current_match, cmd_output, way, direction, floating_con, px);
702     } else {
703         if (strcmp(direction, "width") == 0 ||
704             strcmp(direction, "height") == 0) {
705             if (!cmd_resize_tiling_width_height(current_match, cmd_output, way, direction, ppt))
706                 return;
707         } else {
708             if (!cmd_resize_tiling_direction(current_match, cmd_output, way, direction, ppt))
709                 return;
710         }
711     }
712
713     cmd_output->needs_tree_render = true;
714     // XXX: default reply for now, make this a better reply
715     ysuccess(true);
716 }
717
718 /*
719  * Implementation of 'border normal|none|1pixel|toggle'.
720  *
721  */
722 void cmd_border(I3_CMD, char *border_style_str) {
723     DLOG("border style should be changed to %s\n", border_style_str);
724     owindow *current;
725
726     HANDLE_EMPTY_MATCH;
727
728     TAILQ_FOREACH(current, &owindows, owindows) {
729         DLOG("matching: %p / %s\n", current->con, current->con->name);
730         int border_style = current->con->border_style;
731         if (strcmp(border_style_str, "toggle") == 0) {
732             border_style++;
733             border_style %= 3;
734         } else {
735             if (strcmp(border_style_str, "normal") == 0)
736                 border_style = BS_NORMAL;
737             else if (strcmp(border_style_str, "none") == 0)
738                 border_style = BS_NONE;
739             else if (strcmp(border_style_str, "1pixel") == 0)
740                 border_style = BS_1PIXEL;
741             else {
742                 ELOG("BUG: called with border_style=%s\n", border_style_str);
743                 ysuccess(false);
744                 return;
745             }
746         }
747         con_set_border_style(current->con, border_style);
748     }
749
750     cmd_output->needs_tree_render = true;
751     // XXX: default reply for now, make this a better reply
752     ysuccess(true);
753 }
754
755 /*
756  * Implementation of 'nop <comment>'.
757  *
758  */
759 void cmd_nop(I3_CMD, char *comment) {
760     LOG("-------------------------------------------------\n");
761     LOG("  NOP: %s\n", comment);
762     LOG("-------------------------------------------------\n");
763 }
764
765 /*
766  * Implementation of 'append_layout <path>'.
767  *
768  */
769 void cmd_append_layout(I3_CMD, char *path) {
770     LOG("Appending layout \"%s\"\n", path);
771     tree_append_json(path);
772
773     cmd_output->needs_tree_render = true;
774     // XXX: default reply for now, make this a better reply
775     ysuccess(true);
776 }
777
778 /*
779  * Implementation of 'workspace next|prev|next_on_output|prev_on_output'.
780  *
781  */
782 void cmd_workspace(I3_CMD, char *which) {
783     Con *ws;
784
785     DLOG("which=%s\n", which);
786
787     if (strcmp(which, "next") == 0)
788         ws = workspace_next();
789     else if (strcmp(which, "prev") == 0)
790         ws = workspace_prev();
791     else if (strcmp(which, "next_on_output") == 0)
792         ws = workspace_next_on_output();
793     else if (strcmp(which, "prev_on_output") == 0)
794         ws = workspace_prev_on_output();
795     else {
796         ELOG("BUG: called with which=%s\n", which);
797         ysuccess(false);
798         return;
799     }
800
801     workspace_show(ws);
802
803     cmd_output->needs_tree_render = true;
804     // XXX: default reply for now, make this a better reply
805     ysuccess(true);
806 }
807
808 /*
809  * Implementation of 'workspace number <number>'
810  *
811  */
812 void cmd_workspace_number(I3_CMD, char *which) {
813     Con *output, *workspace = NULL;
814
815     char *endptr = NULL;
816     long parsed_num = strtol(which, &endptr, 10);
817     if (parsed_num == LONG_MIN ||
818         parsed_num == LONG_MAX ||
819         parsed_num < 0 ||
820         *endptr != '\0') {
821         LOG("Could not parse \"%s\" as a number.\n", which);
822         y(map_open);
823         ystr("success");
824         y(bool, false);
825         ystr("error");
826         // TODO: better error message
827         ystr("Could not parse number");
828         y(map_close);
829
830         return;
831     }
832
833     TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
834         GREP_FIRST(workspace, output_get_content(output),
835             child->num == parsed_num);
836
837     if (!workspace) {
838         LOG("There is no workspace with number %d, creating a new one.\n", parsed_num);
839         ysuccess(true);
840         /* terminate the which string after the endposition of the number */
841         *endptr = '\0';
842         if (maybe_back_and_forth(cmd_output, which))
843             return;
844         workspace_show_by_name(which);
845         cmd_output->needs_tree_render = true;
846         return;
847     }
848     if (maybe_back_and_forth(cmd_output, which))
849         return;
850     workspace_show(workspace);
851
852     cmd_output->needs_tree_render = true;
853     // XXX: default reply for now, make this a better reply
854     ysuccess(true);
855 }
856
857 /*
858  * Implementation of 'workspace back_and_forth'.
859  *
860  */
861 void cmd_workspace_back_and_forth(I3_CMD) {
862     workspace_back_and_forth();
863
864     cmd_output->needs_tree_render = true;
865     // XXX: default reply for now, make this a better reply
866     ysuccess(true);
867 }
868
869 /*
870  * Implementation of 'workspace <name>'
871  *
872  */
873 void cmd_workspace_name(I3_CMD, char *name) {
874     if (strncasecmp(name, "__i3_", strlen("__i3_")) == 0) {
875         LOG("You cannot switch to the i3 internal workspaces.\n");
876         ysuccess(false);
877         return;
878     }
879
880     DLOG("should switch to workspace %s\n", name);
881     if (maybe_back_and_forth(cmd_output, name))
882        return;
883     workspace_show_by_name(name);
884
885     cmd_output->needs_tree_render = true;
886     // XXX: default reply for now, make this a better reply
887     ysuccess(true);
888 }
889
890 /*
891  * Implementation of 'mark <mark>'
892  *
893  */
894 void cmd_mark(I3_CMD, char *mark) {
895     DLOG("Clearing all windows which have that mark first\n");
896
897     Con *con;
898     TAILQ_FOREACH(con, &all_cons, all_cons) {
899         if (con->mark && strcmp(con->mark, mark) == 0)
900             FREE(con->mark);
901     }
902
903     DLOG("marking window with str %s\n", mark);
904     owindow *current;
905
906     HANDLE_EMPTY_MATCH;
907
908     TAILQ_FOREACH(current, &owindows, owindows) {
909         DLOG("matching: %p / %s\n", current->con, current->con->name);
910         current->con->mark = sstrdup(mark);
911     }
912
913     cmd_output->needs_tree_render = true;
914     // XXX: default reply for now, make this a better reply
915     ysuccess(true);
916 }
917
918 /*
919  * Implementation of 'mode <string>'.
920  *
921  */
922 void cmd_mode(I3_CMD, char *mode) {
923     DLOG("mode=%s\n", mode);
924     switch_mode(mode);
925
926     // XXX: default reply for now, make this a better reply
927     ysuccess(true);
928 }
929
930 /*
931  * Implementation of 'move [window|container] [to] output <str>'.
932  *
933  */
934 void cmd_move_con_to_output(I3_CMD, char *name) {
935     owindow *current;
936
937     DLOG("should move window to output %s\n", name);
938
939     HANDLE_EMPTY_MATCH;
940
941     /* get the output */
942     Output *current_output = NULL;
943     Output *output;
944
945     // TODO: fix the handling of criteria
946     TAILQ_FOREACH(current, &owindows, owindows)
947         current_output = get_output_containing(current->con->rect.x, current->con->rect.y);
948
949     assert(current_output != NULL);
950
951     // TODO: clean this up with commands.spec as soon as we switched away from the lex/yacc command parser
952     if (strcasecmp(name, "up") == 0)
953         output = get_output_next(D_UP, current_output);
954     else if (strcasecmp(name, "down") == 0)
955         output = get_output_next(D_DOWN, current_output);
956     else if (strcasecmp(name, "left") == 0)
957         output = get_output_next(D_LEFT, current_output);
958     else if (strcasecmp(name, "right") == 0)
959         output = get_output_next(D_RIGHT, current_output);
960     else
961         output = get_output_by_name(name);
962
963     if (!output) {
964         LOG("No such output found.\n");
965         ysuccess(false);
966         return;
967     }
968
969     /* get visible workspace on output */
970     Con *ws = NULL;
971     GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
972     if (!ws) {
973         ysuccess(false);
974         return;
975     }
976
977     TAILQ_FOREACH(current, &owindows, owindows) {
978         DLOG("matching: %p / %s\n", current->con, current->con->name);
979         con_move_to_workspace(current->con, ws, true, false);
980     }
981
982     cmd_output->needs_tree_render = true;
983     // XXX: default reply for now, make this a better reply
984     ysuccess(true);
985 }
986
987 /*
988  * Implementation of 'floating enable|disable|toggle'
989  *
990  */
991 void cmd_floating(I3_CMD, char *floating_mode) {
992     owindow *current;
993
994     DLOG("floating_mode=%s\n", floating_mode);
995
996     HANDLE_EMPTY_MATCH;
997
998     TAILQ_FOREACH(current, &owindows, owindows) {
999         DLOG("matching: %p / %s\n", current->con, current->con->name);
1000         if (strcmp(floating_mode, "toggle") == 0) {
1001             DLOG("should toggle mode\n");
1002             toggle_floating_mode(current->con, false);
1003         } else {
1004             DLOG("should switch mode to %s\n", floating_mode);
1005             if (strcmp(floating_mode, "enable") == 0) {
1006                 floating_enable(current->con, false);
1007             } else {
1008                 floating_disable(current->con, false);
1009             }
1010         }
1011     }
1012
1013     cmd_output->needs_tree_render = true;
1014     // XXX: default reply for now, make this a better reply
1015     ysuccess(true);
1016 }
1017
1018 /*
1019  * Implementation of 'move workspace to [output] <str>'.
1020  *
1021  */
1022 void cmd_move_workspace_to_output(I3_CMD, char *name) {
1023     DLOG("should move workspace to output %s\n", name);
1024
1025     HANDLE_EMPTY_MATCH;
1026
1027     owindow *current;
1028     TAILQ_FOREACH(current, &owindows, owindows) {
1029         Output *current_output = get_output_containing(current->con->rect.x,
1030                                                        current->con->rect.y);
1031         if (!current_output) {
1032             ELOG("Cannot get current output. This is a bug in i3.\n");
1033             ysuccess(false);
1034             return;
1035         }
1036         Output *output = get_output_from_string(current_output, name);
1037         if (!output) {
1038             ELOG("Could not get output from string \"%s\"\n", name);
1039             ysuccess(false);
1040             return;
1041         }
1042
1043         Con *content = output_get_content(output->con);
1044         LOG("got output %p with content %p\n", output, content);
1045
1046         Con *ws = con_get_workspace(current->con);
1047         LOG("should move workspace %p / %s\n", ws, ws->name);
1048
1049         if (con_num_children(ws->parent) == 1) {
1050             LOG("Creating a new workspace to replace \"%s\" (last on its output).\n", ws->name);
1051
1052             /* check if we can find a workspace assigned to this output */
1053             bool used_assignment = false;
1054             struct Workspace_Assignment *assignment;
1055             TAILQ_FOREACH(assignment, &ws_assignments, ws_assignments) {
1056                 if (strcmp(assignment->output, current_output->name) != 0)
1057                     continue;
1058
1059                 /* check if this workspace is already attached to the tree */
1060                 Con *workspace = NULL, *out;
1061                 TAILQ_FOREACH(out, &(croot->nodes_head), nodes)
1062                     GREP_FIRST(workspace, output_get_content(out),
1063                                !strcasecmp(child->name, assignment->name));
1064                 if (workspace != NULL)
1065                     continue;
1066
1067                 /* so create the workspace referenced to by this assignment */
1068                 LOG("Creating workspace from assignment %s.\n", assignment->name);
1069                 workspace_get(assignment->name, NULL);
1070                 used_assignment = true;
1071                 break;
1072             }
1073
1074             /* if we couldn't create the workspace using an assignment, create
1075              * it on the output */
1076             if (!used_assignment)
1077                 create_workspace_on_output(current_output, ws->parent);
1078
1079             /* notify the IPC listeners */
1080             ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"init\"}");
1081         }
1082
1083         /* detach from the old output and attach to the new output */
1084         bool workspace_was_visible = workspace_is_visible(ws);
1085         Con *old_content = ws->parent;
1086         con_detach(ws);
1087         if (workspace_was_visible) {
1088             /* The workspace which we just detached was visible, so focus
1089              * the next one in the focus-stack. */
1090             Con *focus_ws = TAILQ_FIRST(&(old_content->focus_head));
1091             LOG("workspace was visible, focusing %p / %s now\n", focus_ws, focus_ws->name);
1092             workspace_show(focus_ws);
1093         }
1094         con_attach(ws, content, false);
1095
1096         /* fix the coordinates of the floating containers */
1097         Con *floating_con;
1098         TAILQ_FOREACH(floating_con, &(ws->floating_head), floating_windows)
1099             floating_fix_coordinates(floating_con, &(old_content->rect), &(content->rect));
1100
1101         ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"move\"}");
1102         if (workspace_was_visible) {
1103             /* Focus the moved workspace on the destination output. */
1104             workspace_show(ws);
1105         }
1106     }
1107
1108     cmd_output->needs_tree_render = true;
1109     // XXX: default reply for now, make this a better reply
1110     ysuccess(true);
1111 }
1112
1113 /*
1114  * Implementation of 'split v|h|vertical|horizontal'.
1115  *
1116  */
1117 void cmd_split(I3_CMD, char *direction) {
1118     /* TODO: use matches */
1119     LOG("splitting in direction %c\n", direction[0]);
1120     tree_split(focused, (direction[0] == 'v' ? VERT : HORIZ));
1121
1122     cmd_output->needs_tree_render = true;
1123     // XXX: default reply for now, make this a better reply
1124     ysuccess(true);
1125 }
1126
1127 /*
1128  * Implementaiton of 'kill [window|client]'.
1129  *
1130  */
1131 void cmd_kill(I3_CMD, char *kill_mode_str) {
1132     if (kill_mode_str == NULL)
1133         kill_mode_str = "window";
1134     owindow *current;
1135
1136     DLOG("kill_mode=%s\n", kill_mode_str);
1137
1138     int kill_mode;
1139     if (strcmp(kill_mode_str, "window") == 0)
1140         kill_mode = KILL_WINDOW;
1141     else if (strcmp(kill_mode_str, "client") == 0)
1142         kill_mode = KILL_CLIENT;
1143     else {
1144         ELOG("BUG: called with kill_mode=%s\n", kill_mode_str);
1145         ysuccess(false);
1146         return;
1147     }
1148
1149     /* check if the match is empty, not if the result is empty */
1150     if (match_is_empty(current_match))
1151         tree_close_con(kill_mode);
1152     else {
1153         TAILQ_FOREACH(current, &owindows, owindows) {
1154             DLOG("matching: %p / %s\n", current->con, current->con->name);
1155             tree_close(current->con, kill_mode, false, false);
1156         }
1157     }
1158
1159     cmd_output->needs_tree_render = true;
1160     // XXX: default reply for now, make this a better reply
1161     ysuccess(true);
1162 }
1163
1164 /*
1165  * Implementation of 'exec [--no-startup-id] <command>'.
1166  *
1167  */
1168 void cmd_exec(I3_CMD, char *nosn, char *command) {
1169     bool no_startup_id = (nosn != NULL);
1170
1171     DLOG("should execute %s, no_startup_id = %d\n", command, no_startup_id);
1172     start_application(command, no_startup_id);
1173
1174     // XXX: default reply for now, make this a better reply
1175     ysuccess(true);
1176 }
1177
1178 /*
1179  * Implementation of 'focus left|right|up|down'.
1180  *
1181  */
1182 void cmd_focus_direction(I3_CMD, char *direction) {
1183     if (focused &&
1184         focused->type != CT_WORKSPACE &&
1185         focused->fullscreen_mode != CF_NONE) {
1186         LOG("Cannot change focus while in fullscreen mode.\n");
1187         ysuccess(false);
1188         return;
1189     }
1190
1191     DLOG("direction = *%s*\n", direction);
1192
1193     if (strcmp(direction, "left") == 0)
1194         tree_next('p', HORIZ);
1195     else if (strcmp(direction, "right") == 0)
1196         tree_next('n', HORIZ);
1197     else if (strcmp(direction, "up") == 0)
1198         tree_next('p', VERT);
1199     else if (strcmp(direction, "down") == 0)
1200         tree_next('n', VERT);
1201     else {
1202         ELOG("Invalid focus direction (%s)\n", direction);
1203         ysuccess(false);
1204         return;
1205     }
1206
1207     cmd_output->needs_tree_render = true;
1208     // XXX: default reply for now, make this a better reply
1209     ysuccess(true);
1210 }
1211
1212 /*
1213  * Implementation of 'focus tiling|floating|mode_toggle'.
1214  *
1215  */
1216 void cmd_focus_window_mode(I3_CMD, char *window_mode) {
1217     if (focused &&
1218         focused->type != CT_WORKSPACE &&
1219         focused->fullscreen_mode != CF_NONE) {
1220         LOG("Cannot change focus while in fullscreen mode.\n");
1221         ysuccess(false);
1222         return;
1223     }
1224
1225     DLOG("window_mode = %s\n", window_mode);
1226
1227     Con *ws = con_get_workspace(focused);
1228     Con *current;
1229     if (ws != NULL) {
1230         if (strcmp(window_mode, "mode_toggle") == 0) {
1231             current = TAILQ_FIRST(&(ws->focus_head));
1232             if (current != NULL && current->type == CT_FLOATING_CON)
1233                 window_mode = "tiling";
1234             else window_mode = "floating";
1235         }
1236         TAILQ_FOREACH(current, &(ws->focus_head), focused) {
1237             if ((strcmp(window_mode, "floating") == 0 && current->type != CT_FLOATING_CON) ||
1238                 (strcmp(window_mode, "tiling") == 0 && current->type == CT_FLOATING_CON))
1239                 continue;
1240
1241             con_focus(con_descend_focused(current));
1242             break;
1243         }
1244     }
1245
1246     cmd_output->needs_tree_render = true;
1247     // XXX: default reply for now, make this a better reply
1248     ysuccess(true);
1249 }
1250
1251 /*
1252  * Implementation of 'focus parent|child'.
1253  *
1254  */
1255 void cmd_focus_level(I3_CMD, char *level) {
1256     DLOG("level = %s\n", level);
1257     bool success = false;
1258
1259     /* Focusing the parent can only be allowed if the newly
1260      * focused container won't escape the fullscreen container. */
1261     if (strcmp(level, "parent") == 0) {
1262         if (focused && focused->parent) {
1263             if (con_fullscreen_permits_focusing(focused->parent))
1264                 success = level_up();
1265             else
1266                 LOG("Currently in fullscreen, not going up\n");
1267         }
1268     }
1269
1270     /* Focusing a child should always be allowed. */
1271     else success = level_down();
1272
1273     cmd_output->needs_tree_render = success;
1274     // XXX: default reply for now, make this a better reply
1275     ysuccess(success);
1276 }
1277
1278 /*
1279  * Implementation of 'focus'.
1280  *
1281  */
1282 void cmd_focus(I3_CMD) {
1283     DLOG("current_match = %p\n", current_match);
1284
1285     if (match_is_empty(current_match)) {
1286         ELOG("You have to specify which window/container should be focused.\n");
1287         ELOG("Example: [class=\"urxvt\" title=\"irssi\"] focus\n");
1288
1289         y(map_open);
1290         ystr("success");
1291         y(bool, false);
1292         ystr("error");
1293         ystr("You have to specify which window/container should be focused");
1294         y(map_close);
1295
1296         return;
1297     }
1298
1299     int count = 0;
1300     owindow *current;
1301     TAILQ_FOREACH(current, &owindows, owindows) {
1302         Con *ws = con_get_workspace(current->con);
1303         /* If no workspace could be found, this was a dock window.
1304          * Just skip it, you cannot focus dock windows. */
1305         if (!ws)
1306             continue;
1307
1308         /* Check the fullscreen focus constraints. */
1309         if (!con_fullscreen_permits_focusing(current->con)) {
1310             LOG("Cannot change focus while in fullscreen mode (fullscreen rules).\n");
1311             ysuccess(false);
1312             return;
1313         }
1314
1315         /* If the container is not on the current workspace,
1316          * workspace_show() will switch to a different workspace and (if
1317          * enabled) trigger a mouse pointer warp to the currently focused
1318          * container (!) on the target workspace.
1319          *
1320          * Therefore, before calling workspace_show(), we make sure that
1321          * 'current' will be focused on the workspace. However, we cannot
1322          * just con_focus(current) because then the pointer will not be
1323          * warped at all (the code thinks we are already there).
1324          *
1325          * So we focus 'current' to make it the currently focused window of
1326          * the target workspace, then revert focus. */
1327         Con *currently_focused = focused;
1328         con_focus(current->con);
1329         con_focus(currently_focused);
1330
1331         /* Now switch to the workspace, then focus */
1332         workspace_show(ws);
1333         LOG("focusing %p / %s\n", current->con, current->con->name);
1334         con_focus(current->con);
1335         count++;
1336     }
1337
1338     if (count > 1)
1339         LOG("WARNING: Your criteria for the focus command matches %d containers, "
1340             "while only exactly one container can be focused at a time.\n", count);
1341
1342     cmd_output->needs_tree_render = true;
1343     // XXX: default reply for now, make this a better reply
1344     ysuccess(true);
1345 }
1346
1347 /*
1348  * Implementation of 'fullscreen [global]'.
1349  *
1350  */
1351 void cmd_fullscreen(I3_CMD, char *fullscreen_mode) {
1352     if (fullscreen_mode == NULL)
1353         fullscreen_mode = "output";
1354     DLOG("toggling fullscreen, mode = %s\n", fullscreen_mode);
1355     owindow *current;
1356
1357     HANDLE_EMPTY_MATCH;
1358
1359     TAILQ_FOREACH(current, &owindows, owindows) {
1360         printf("matching: %p / %s\n", current->con, current->con->name);
1361         con_toggle_fullscreen(current->con, (strcmp(fullscreen_mode, "global") == 0 ? CF_GLOBAL : CF_OUTPUT));
1362     }
1363
1364     cmd_output->needs_tree_render = true;
1365     // XXX: default reply for now, make this a better reply
1366     ysuccess(true);
1367 }
1368
1369 /*
1370  * Implementation of 'move <direction> [<pixels> [px]]'.
1371  *
1372  */
1373 void cmd_move_direction(I3_CMD, char *direction, char *move_px) {
1374     // 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
1375     int px = atoi(move_px);
1376
1377     /* TODO: make 'move' work with criteria. */
1378     DLOG("moving in direction %s, px %s\n", direction, move_px);
1379     if (con_is_floating(focused)) {
1380         DLOG("floating move with %d pixels\n", px);
1381         Rect newrect = focused->parent->rect;
1382         if (strcmp(direction, "left") == 0) {
1383             newrect.x -= px;
1384         } else if (strcmp(direction, "right") == 0) {
1385             newrect.x += px;
1386         } else if (strcmp(direction, "up") == 0) {
1387             newrect.y -= px;
1388         } else if (strcmp(direction, "down") == 0) {
1389             newrect.y += px;
1390         }
1391         floating_reposition(focused->parent, newrect);
1392     } else {
1393         tree_move((strcmp(direction, "right") == 0 ? D_RIGHT :
1394                    (strcmp(direction, "left") == 0 ? D_LEFT :
1395                     (strcmp(direction, "up") == 0 ? D_UP :
1396                      D_DOWN))));
1397         cmd_output->needs_tree_render = true;
1398     }
1399
1400     // XXX: default reply for now, make this a better reply
1401     ysuccess(true);
1402 }
1403
1404 /*
1405  * Implementation of 'layout default|stacked|stacking|tabbed|splitv|splith'.
1406  *
1407  */
1408 void cmd_layout(I3_CMD, char *layout_str) {
1409     if (strcmp(layout_str, "stacking") == 0)
1410         layout_str = "stacked";
1411     owindow *current;
1412     int layout;
1413     /* default is a special case which will be handled in con_set_layout(). */
1414     if (strcmp(layout_str, "default") == 0)
1415         layout = L_DEFAULT;
1416     else if (strcmp(layout_str, "stacked") == 0)
1417         layout = L_STACKED;
1418     else if (strcmp(layout_str, "tabbed") == 0)
1419         layout = L_TABBED;
1420     else if (strcmp(layout_str, "splitv") == 0)
1421         layout = L_SPLITV;
1422     else if (strcmp(layout_str, "splith") == 0)
1423         layout = L_SPLITH;
1424
1425     DLOG("changing layout to %s (%d)\n", layout_str, layout);
1426
1427     /* check if the match is empty, not if the result is empty */
1428     if (match_is_empty(current_match))
1429         con_set_layout(focused->parent, layout);
1430     else {
1431         TAILQ_FOREACH(current, &owindows, owindows) {
1432             DLOG("matching: %p / %s\n", current->con, current->con->name);
1433             con_set_layout(current->con, layout);
1434         }
1435     }
1436
1437     cmd_output->needs_tree_render = true;
1438     // XXX: default reply for now, make this a better reply
1439     ysuccess(true);
1440 }
1441
1442 /*
1443  * Implementation of 'layout toggle [all|split]'.
1444  *
1445  */
1446 void cmd_layout_toggle(I3_CMD, char *toggle_mode) {
1447     owindow *current;
1448
1449     if (toggle_mode == NULL)
1450         toggle_mode = "default";
1451
1452     DLOG("toggling layout (mode = %s)\n", toggle_mode);
1453
1454     /* check if the match is empty, not if the result is empty */
1455     if (match_is_empty(current_match))
1456         con_toggle_layout(focused->parent, toggle_mode);
1457     else {
1458         TAILQ_FOREACH(current, &owindows, owindows) {
1459             DLOG("matching: %p / %s\n", current->con, current->con->name);
1460             con_toggle_layout(current->con, toggle_mode);
1461         }
1462     }
1463
1464     cmd_output->needs_tree_render = true;
1465     // XXX: default reply for now, make this a better reply
1466     ysuccess(true);
1467 }
1468
1469 /*
1470  * Implementaiton of 'exit'.
1471  *
1472  */
1473 void cmd_exit(I3_CMD) {
1474     LOG("Exiting due to user command.\n");
1475     xcb_disconnect(conn);
1476     exit(0);
1477
1478     /* unreached */
1479 }
1480
1481 /*
1482  * Implementaiton of 'reload'.
1483  *
1484  */
1485 void cmd_reload(I3_CMD) {
1486     LOG("reloading\n");
1487     kill_configerror_nagbar(false);
1488     kill_commanderror_nagbar(false);
1489     load_configuration(conn, NULL, true);
1490     x_set_i3_atoms();
1491     /* Send an IPC event just in case the ws names have changed */
1492     ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"reload\"}");
1493
1494     // XXX: default reply for now, make this a better reply
1495     ysuccess(true);
1496 }
1497
1498 /*
1499  * Implementaiton of 'restart'.
1500  *
1501  */
1502 void cmd_restart(I3_CMD) {
1503     LOG("restarting i3\n");
1504     i3_restart(false);
1505
1506     // XXX: default reply for now, make this a better reply
1507     ysuccess(true);
1508 }
1509
1510 /*
1511  * Implementaiton of 'open'.
1512  *
1513  */
1514 void cmd_open(I3_CMD) {
1515     LOG("opening new container\n");
1516     Con *con = tree_open_con(NULL, NULL);
1517     con->layout = L_SPLITH;
1518     con_focus(con);
1519
1520     y(map_open);
1521     ystr("success");
1522     y(bool, true);
1523     ystr("id");
1524     y(integer, (long int)con);
1525     y(map_close);
1526
1527     cmd_output->needs_tree_render = true;
1528 }
1529
1530 /*
1531  * Implementation of 'focus output <output>'.
1532  *
1533  */
1534 void cmd_focus_output(I3_CMD, char *name) {
1535     owindow *current;
1536
1537     DLOG("name = %s\n", name);
1538
1539     HANDLE_EMPTY_MATCH;
1540
1541     /* get the output */
1542     Output *current_output = NULL;
1543     Output *output;
1544
1545     TAILQ_FOREACH(current, &owindows, owindows)
1546         current_output = get_output_containing(current->con->rect.x, current->con->rect.y);
1547     assert(current_output != NULL);
1548
1549     output = get_output_from_string(current_output, name);
1550
1551     if (!output) {
1552         LOG("No such output found.\n");
1553         ysuccess(false);
1554         return;
1555     }
1556
1557     /* get visible workspace on output */
1558     Con *ws = NULL;
1559     GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
1560     if (!ws) {
1561         ysuccess(false);
1562         return;
1563     }
1564
1565     workspace_show(ws);
1566
1567     cmd_output->needs_tree_render = true;
1568     // XXX: default reply for now, make this a better reply
1569     ysuccess(true);
1570 }
1571
1572 /*
1573  * Implementation of 'move [window|container] [to] [absolute] position <px> [px] <px> [px]
1574  *
1575  */
1576 void cmd_move_window_to_position(I3_CMD, char *method, char *cx, char *cy) {
1577
1578     int x = atoi(cx);
1579     int y = atoi(cy);
1580
1581     if (!con_is_floating(focused)) {
1582         ELOG("Cannot change position. The window/container is not floating\n");
1583         y(map_open);
1584         ystr("success");
1585         y(bool, false);
1586         ystr("error");
1587         ystr("Cannot change position. The window/container is not floating.");
1588         y(map_close);
1589         return;
1590     }
1591
1592     if (strcmp(method, "absolute") == 0) {
1593         focused->parent->rect.x = x;
1594         focused->parent->rect.y = y;
1595
1596         DLOG("moving to absolute position %d %d\n", x, y);
1597         floating_maybe_reassign_ws(focused->parent);
1598         cmd_output->needs_tree_render = true;
1599     }
1600
1601     if (strcmp(method, "position") == 0) {
1602         Rect newrect = focused->parent->rect;
1603
1604         DLOG("moving to position %d %d\n", x, y);
1605         newrect.x = x;
1606         newrect.y = y;
1607
1608         floating_reposition(focused->parent, newrect);
1609     }
1610
1611     // XXX: default reply for now, make this a better reply
1612     ysuccess(true);
1613 }
1614
1615 /*
1616  * Implementation of 'move [window|container] [to] [absolute] position center
1617  *
1618  */
1619 void cmd_move_window_to_center(I3_CMD, char *method) {
1620
1621     if (!con_is_floating(focused)) {
1622         ELOG("Cannot change position. The window/container is not floating\n");
1623         y(map_open);
1624         ystr("success");
1625         y(bool, false);
1626         ystr("error");
1627         ystr("Cannot change position. The window/container is not floating.");
1628         y(map_close);
1629     }
1630
1631     if (strcmp(method, "absolute") == 0) {
1632         Rect *rect = &focused->parent->rect;
1633
1634         DLOG("moving to absolute center\n");
1635         rect->x = croot->rect.width/2 - rect->width/2;
1636         rect->y = croot->rect.height/2 - rect->height/2;
1637
1638         floating_maybe_reassign_ws(focused->parent);
1639         cmd_output->needs_tree_render = true;
1640     }
1641
1642     if (strcmp(method, "position") == 0) {
1643         Rect *wsrect = &con_get_workspace(focused)->rect;
1644         Rect newrect = focused->parent->rect;
1645
1646         DLOG("moving to center\n");
1647         newrect.x = wsrect->width/2 - newrect.width/2;
1648         newrect.y = wsrect->height/2 - newrect.height/2;
1649
1650         floating_reposition(focused->parent, newrect);
1651     }
1652
1653     // XXX: default reply for now, make this a better reply
1654     ysuccess(true);
1655 }
1656
1657 /*
1658  * Implementation of 'move scratchpad'.
1659  *
1660  */
1661 void cmd_move_scratchpad(I3_CMD) {
1662     DLOG("should move window to scratchpad\n");
1663     owindow *current;
1664
1665     HANDLE_EMPTY_MATCH;
1666
1667     TAILQ_FOREACH(current, &owindows, owindows) {
1668         DLOG("matching: %p / %s\n", current->con, current->con->name);
1669         scratchpad_move(current->con);
1670     }
1671
1672     cmd_output->needs_tree_render = true;
1673     // XXX: default reply for now, make this a better reply
1674     ysuccess(true);
1675 }
1676
1677 /*
1678  * Implementation of 'scratchpad show'.
1679  *
1680  */
1681 void cmd_scratchpad_show(I3_CMD) {
1682     DLOG("should show scratchpad window\n");
1683     owindow *current;
1684
1685     if (match_is_empty(current_match)) {
1686         scratchpad_show(NULL);
1687     } else {
1688         TAILQ_FOREACH(current, &owindows, owindows) {
1689             DLOG("matching: %p / %s\n", current->con, current->con->name);
1690             scratchpad_show(current->con);
1691         }
1692     }
1693
1694     cmd_output->needs_tree_render = true;
1695     // XXX: default reply for now, make this a better reply
1696     ysuccess(true);
1697 }
1698
1699 /*
1700  * Implementation of 'rename workspace <name> to <name>'
1701  *
1702  */
1703 void cmd_rename_workspace(I3_CMD, char *old_name, char *new_name) {
1704     LOG("Renaming workspace \"%s\" to \"%s\"\n", old_name, new_name);
1705
1706     Con *output, *workspace = NULL;
1707     TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
1708         GREP_FIRST(workspace, output_get_content(output),
1709             !strcasecmp(child->name, old_name));
1710
1711     if (!workspace) {
1712         // TODO: we should include the old workspace name here and use yajl for
1713         // generating the reply.
1714         y(map_open);
1715         ystr("success");
1716         y(bool, false);
1717         ystr("error");
1718         // TODO: better error message
1719         ystr("Old workspace not found");
1720         y(map_close);
1721         return;
1722     }
1723
1724     Con *check_dest = NULL;
1725     TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
1726         GREP_FIRST(check_dest, output_get_content(output),
1727             !strcasecmp(child->name, new_name));
1728
1729     if (check_dest != NULL) {
1730         // TODO: we should include the new workspace name here and use yajl for
1731         // generating the reply.
1732         y(map_open);
1733         ystr("success");
1734         y(bool, false);
1735         ystr("error");
1736         // TODO: better error message
1737         ystr("New workspace already exists");
1738         y(map_close);
1739         return;
1740     }
1741
1742     /* Change the name and try to parse it as a number. */
1743     FREE(workspace->name);
1744     workspace->name = sstrdup(new_name);
1745     char *endptr = NULL;
1746     long parsed_num = strtol(new_name, &endptr, 10);
1747     if (parsed_num == LONG_MIN ||
1748         parsed_num == LONG_MAX ||
1749         parsed_num < 0 ||
1750         endptr == new_name)
1751         workspace->num = -1;
1752     else workspace->num = parsed_num;
1753     LOG("num = %d\n", workspace->num);
1754
1755     /* By re-attaching, the sort order will be correct afterwards. */
1756     Con *previously_focused = focused;
1757     Con *parent = workspace->parent;
1758     con_detach(workspace);
1759     con_attach(workspace, parent, false);
1760     /* Restore the previous focus since con_attach messes with the focus. */
1761     con_focus(previously_focused);
1762
1763     cmd_output->needs_tree_render = true;
1764     ysuccess(true);
1765
1766     ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"rename\"}");
1767 }