nixo
/
gri3-wm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
gri3-wm/src/commands.c

2203 lines
69 KiB
C
Raw Normal View History

use I3__FILE__ for DLOG, leave __FILE__ as is See also commit 0e752070ac2bed02d0858bbc450ddcee36e3b9b5, which broke source code listings in gdb unless you cd into i3/src. This should give us best of both :-).
2012-08-12 12:18:43 +02:00
#undef I3__FILE__
#define I3__FILE__ "commands.c"
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
/*
* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
* © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE)
*
* commands.c: all command functions (see commands_parser.c)
*
*/
#include <float.h>
Implement a new parser for commands. (+test) On the rationale of using a custom parser instead of a lex/yacc one, see this quote from src/commands_parser.c: We use a hand-written parser instead of lex/yacc because our commands are easy for humans, not for computers. Thus, it’s quite hard to specify a context-free grammar for the commands. A PEG grammar would be easier, but there’s downsides to every PEG parser generator I have come accross so far. This parser is basically a state machine which looks for literals or strings and can push either on a stack. After identifying a literal or string, it will either transition to the current state, to a different state, or call a function (like cmd_move()). Special care has been taken that error messages are useful and the code is well testable (when compiled with -DTEST_PARSER it will output to stdout instead of actually calling any function). During the migration phase (I plan to completely switch to this parser before 4.2 will be released), the new parser will parse every command you send to i3 and save the resulting call stack. Then, the old parser will parse your input and actually execute the commands. Afterwards, both call stacks will be compared and any differences will be logged. The new parser works with 100% of the test suite and produces identical call stacks.
2012-01-14 20:53:29 +01:00
#include <stdarg.h>
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
#include "all.h"
Implement shmlog command Add shmlog command that takes <size>|toggle|on|off. Separate logbuffer management into open_logbuffer() and close_logbuffer(). Make t/187-commands-parser.t expect 'shmlog'. Add update_shmlog_atom() to update the SHMLOG_PATH. Document the shmlog command in userguide.
2013-06-05 15:04:57 +02:00
#include "shmlog.h"
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
// Macros to make the YAJL API a bit easier to use.
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
#define y(x, ...) (cmd_output->json_gen != NULL ? yajl_gen_##x(cmd_output->json_gen, ##__VA_ARGS__) : 0)
#define ystr(str) (cmd_output->json_gen != NULL ? yajl_gen_string(cmd_output->json_gen, (unsigned char *)str, strlen(str)) : 0)
#define ysuccess(success) \
do { \
if (cmd_output->json_gen != NULL) { \
y(map_open); \
ystr("success"); \
y(bool, success); \
y(map_close); \
} \
} while (0)
#define yerror(message) \
do { \
if (cmd_output->json_gen != NULL) { \
y(map_open); \
ystr("success"); \
y(bool, false); \
ystr("error"); \
ystr(message); \
y(map_close); \
} \
} while (0)
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
/** When the command did not include match criteria (!), we use the currently
Fix a mistake in comment
2012-05-09 23:39:44 +02:00
* focused container. Do not confuse this case with a command which included
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
* criteria but which did not match any windows. This macro has to be called in
* every command.
*/
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
#define HANDLE_EMPTY_MATCH \
do { \
if (match_is_empty(current_match)) { \
owindow *ow = smalloc(sizeof(owindow)); \
ow->con = focused; \
TAILQ_INIT(&owindows); \
TAILQ_INSERT_TAIL(&owindows, ow, owindows); \
} \
} while (0)
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
/*
* Returns true if a is definitely greater than b (using the given epsilon)
*
*/
static bool definitelyGreaterThan(float a, float b, float epsilon) {
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
return (a - b) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Returns an 'output' corresponding to one of left/right/down/up or a specific
* output name.
*
*/
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
static Output *get_output_from_string(Output *current_output, const char *output_str) {
Output *output;
wrap when moving things to outputs with direction
2013-01-25 00:02:09 +01:00
if (strcasecmp(output_str, "left") == 0)
output = get_output_next_wrap(D_LEFT, current_output);
else if (strcasecmp(output_str, "right") == 0)
output = get_output_next_wrap(D_RIGHT, current_output);
else if (strcasecmp(output_str, "up") == 0)
output = get_output_next_wrap(D_UP, current_output);
else if (strcasecmp(output_str, "down") == 0)
output = get_output_next_wrap(D_DOWN, current_output);
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
else
output = get_output_by_name(output_str);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
return output;
}
Fix output retrieval for floating cons When focusing/moving to outputs, the method of getting the correct output for a given container fails if the container in question is floating and only partially mapped on an output screen. This patch introduces a fail-safe retrieval of the output for any container.
2013-10-22 13:17:23 +02:00
/*
* Returns the output containing the given container.
*/
static Output *get_output_of_con(Con *con) {
Con *output_con = con_get_output(con);
Output *output = get_output_by_name(output_con->name);
assert(output != NULL);
return output;
}
bugfix: less differentiation between named and numbered workspaces calling workspace by number now also checks for switching back and forth and creates a new workspace if no workspace starting with that number is found also removed the obsolete tree_render() in favor of setting cmd_output->needs_tree_render to true
2012-05-02 16:05:27 +02:00
/*
* Checks whether we switched to a new workspace and returns false in that case,
* signaling that further workspace switching should be done by the calling function
* If not, calls workspace_back_and_forth() if workspace_auto_back_and_forth is set
* and return true, signaling that no further workspace switching should occur in the calling function.
*
*/
Change the names of parser result structs Change the name of structs CommandResult and ConfigResult to CommandResultIR and ConfigResultIR to show they are an intermediate representation used during parsing.
2014-05-18 06:44:19 +02:00
static bool maybe_back_and_forth(struct CommandResultIR *cmd_output, char *name) {
bugfix: less differentiation between named and numbered workspaces calling workspace by number now also checks for switching back and forth and creates a new workspace if no workspace starting with that number is found also removed the obsolete tree_render() in favor of setting cmd_output->needs_tree_render to true
2012-05-02 16:05:27 +02:00
Con *ws = con_get_workspace(focused);
/* If we switched to a different workspace, do nothing */
if (strcmp(ws->name, name) != 0)
return false;
DLOG("This workspace is already focused.\n");
maybe_back_and_forth now sets render_tree
2012-05-02 22:27:41 +02:00
if (config.workspace_auto_back_and_forth) {
workspace_back_and_forth();
cmd_output->needs_tree_render = true;
}
return true;
bugfix: less differentiation between named and numbered workspaces calling workspace by number now also checks for switching back and forth and creates a new workspace if no workspace starting with that number is found also removed the obsolete tree_render() in favor of setting cmd_output->needs_tree_render to true
2012-05-02 16:05:27 +02:00
}
fixes #776 this implements both the "move container to workspace back_and_forth" command and movements to the same workspace when auto_back_and_forth is set. it includes documentation and test suite additions by michael. it also simplifies the workspace_show_by_name function (making use of workspace_get accepting NULL pointers).
2012-09-04 10:51:18 +02:00
/*
* Return the passed workspace unless it is the current one and auto back and
* forth is enabled, in which case the back_and_forth workspace is returned.
*/
static Con *maybe_auto_back_and_forth_workspace(Con *workspace) {
Con *current, *baf;
if (!config.workspace_auto_back_and_forth)
return workspace;
current = con_get_workspace(focused);
if (current == workspace) {
baf = workspace_back_and_forth_get();
if (baf != NULL) {
DLOG("Substituting workspace with back_and_forth, as it is focused.\n");
return baf;
}
}
return workspace;
}
Rip out the old command parser, remove migration code
2012-01-27 23:11:03 +01:00
// This code is commented out because we might recycle it for popping up error
// messages on parser errors.
#if 0
Implement a new parser for commands. (+test) On the rationale of using a custom parser instead of a lex/yacc one, see this quote from src/commands_parser.c: We use a hand-written parser instead of lex/yacc because our commands are easy for humans, not for computers. Thus, it’s quite hard to specify a context-free grammar for the commands. A PEG grammar would be easier, but there’s downsides to every PEG parser generator I have come accross so far. This parser is basically a state machine which looks for literals or strings and can push either on a stack. After identifying a literal or string, it will either transition to the current state, to a different state, or call a function (like cmd_move()). Special care has been taken that error messages are useful and the code is well testable (when compiled with -DTEST_PARSER it will output to stdout instead of actually calling any function). During the migration phase (I plan to completely switch to this parser before 4.2 will be released), the new parser will parse every command you send to i3 and save the resulting call stack. Then, the old parser will parse your input and actually execute the commands. Afterwards, both call stacks will be compared and any differences will be logged. The new parser works with 100% of the test suite and produces identical call stacks.
2012-01-14 20:53:29 +01:00
static pid_t migration_pid = -1;
/*
* Handler which will be called when we get a SIGCHLD for the nagbar, meaning
* it exited (or could not be started, depending on the exit code).
*
*/
static void nagbar_exited(EV_P_ ev_child *watcher, int revents) {
ev_child_stop(EV_A_ watcher);
if (!WIFEXITED(watcher->rstatus)) {
fprintf(stderr, "ERROR: i3-nagbar did not exit normally.\n");
return;
}
int exitcode = WEXITSTATUS(watcher->rstatus);
printf("i3-nagbar process exited with status %d\n", exitcode);
if (exitcode == 2) {
fprintf(stderr, "ERROR: i3-nagbar could not be found. Is it correctly installed on your system?\n");
}
migration_pid = -1;
}
/* We need ev >= 4 for the following code. Since it is not *that* important (it
* only makes sure that there are no i3-nagbar instances left behind) we still
* support old systems with libev 3. */
#if EV_VERSION_MAJOR >= 4
/*
* Cleanup handler. Will be called when i3 exits. Kills i3-nagbar with signal
* SIGKILL (9) to make sure there are no left-over i3-nagbar processes.
*
*/
static void nagbar_cleanup(EV_P_ ev_cleanup *watcher, int revent) {
if (migration_pid != -1) {
LOG("Sending SIGKILL (9) to i3-nagbar with PID %d\n", migration_pid);
kill(migration_pid, SIGKILL);
}
}
#endif
Use (void) instead of () for functions without args (Thanks fernandotcl) See also: http://article.gmane.org/gmane.linux.kernel/1268792 The C compiler will handle (void) as "no arguments" and () as "variadic function" (equivalent to (...)) which might lead to subtle errors, such as the one which was fixed with commit 0ea64ae4.
2012-03-31 10:53:04 +02:00
void cmd_MIGRATION_start_nagbar(void) {
Implement a new parser for commands. (+test) On the rationale of using a custom parser instead of a lex/yacc one, see this quote from src/commands_parser.c: We use a hand-written parser instead of lex/yacc because our commands are easy for humans, not for computers. Thus, it’s quite hard to specify a context-free grammar for the commands. A PEG grammar would be easier, but there’s downsides to every PEG parser generator I have come accross so far. This parser is basically a state machine which looks for literals or strings and can push either on a stack. After identifying a literal or string, it will either transition to the current state, to a different state, or call a function (like cmd_move()). Special care has been taken that error messages are useful and the code is well testable (when compiled with -DTEST_PARSER it will output to stdout instead of actually calling any function). During the migration phase (I plan to completely switch to this parser before 4.2 will be released), the new parser will parse every command you send to i3 and save the resulting call stack. Then, the old parser will parse your input and actually execute the commands. Afterwards, both call stacks will be compared and any differences will be logged. The new parser works with 100% of the test suite and produces identical call stacks.
2012-01-14 20:53:29 +01:00
if (migration_pid != -1) {
fprintf(stderr, "i3-nagbar already running.\n");
return;
}
fprintf(stderr, "Starting i3-nagbar, command parsing differs from expected output.\n");
ELOG("Please report this on IRC or in the bugtracker. Make sure to include the full debug level logfile:\n");
ELOG("i3-dump-log | gzip -9c > /tmp/i3.log.gz\n");
ELOG("FYI: Your i3 version is " I3_VERSION "\n");
migration_pid = fork();
if (migration_pid == -1) {
warn("Could not fork()");
return;
}
/* child */
if (migration_pid == 0) {
char *pageraction;
sasprintf(&pageraction, "i3-sensible-terminal -e i3-sensible-pager \"%s\"", errorfilename);
char *argv[] = {
NULL, /* will be replaced by the executable path */
"-t",
"error",
"-m",
"You found a parsing error. Please, please, please, report it!",
"-b",
"show errors",
pageraction,
NULL
};
exec_i3_utility("i3-nagbar", argv);
}
/* parent */
/* install a child watcher */
ev_child *child = smalloc(sizeof(ev_child));
ev_child_init(child, &nagbar_exited, migration_pid, 0);
ev_child_start(main_loop, child);
/* We need ev >= 4 for the following code. Since it is not *that* important (it
* only makes sure that there are no i3-nagbar instances left behind) we still
* support old systems with libev 3. */
#if EV_VERSION_MAJOR >= 4
/* install a cleanup watcher (will be called when i3 exits and i3-nagbar is
* still running) */
ev_cleanup *cleanup = smalloc(sizeof(ev_cleanup));
ev_cleanup_init(cleanup, nagbar_cleanup);
ev_cleanup_start(main_loop, cleanup);
#endif
}
Rip out the old command parser, remove migration code
2012-01-27 23:11:03 +01:00
#endif
Implement a new parser for commands. (+test) On the rationale of using a custom parser instead of a lex/yacc one, see this quote from src/commands_parser.c: We use a hand-written parser instead of lex/yacc because our commands are easy for humans, not for computers. Thus, it’s quite hard to specify a context-free grammar for the commands. A PEG grammar would be easier, but there’s downsides to every PEG parser generator I have come accross so far. This parser is basically a state machine which looks for literals or strings and can push either on a stack. After identifying a literal or string, it will either transition to the current state, to a different state, or call a function (like cmd_move()). Special care has been taken that error messages are useful and the code is well testable (when compiled with -DTEST_PARSER it will output to stdout instead of actually calling any function). During the migration phase (I plan to completely switch to this parser before 4.2 will be released), the new parser will parse every command you send to i3 and save the resulting call stack. Then, the old parser will parse your input and actually execute the commands. Afterwards, both call stacks will be compared and any differences will be logged. The new parser works with 100% of the test suite and produces identical call stacks.
2012-01-14 20:53:29 +01:00
/*******************************************************************************
* Criteria functions.
******************************************************************************/
move owindow definition into the command parser
2012-10-08 13:26:24 +02:00
/*
* Helper data structure for an operation window (window on which the operation
* will be performed). Used to build the TAILQ owindows.
*
*/
typedef struct owindow {
Con *con;
TAILQ_ENTRY(owindow) owindows;
} owindow;
typedef TAILQ_HEAD(owindows_head, owindow) owindows_head;
static owindows_head owindows;
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Initializes the specified 'Match' data structure and the initial state of
* commands.c for matching target windows of a command.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_criteria_init(I3_CMD) {
Bugfix: Free old criteria matching window list (Thanks piroko)
2012-01-27 22:47:55 +01:00
Con *con;
owindow *ow;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("Initializing criteria, current_match = %p\n", current_match);
Free match after criteria initialization This memory leak is associated with matching by a criteria that uses a regular expression. Without freeing a regex before calling match_init, it will definitely be lost.
2014-03-19 09:34:42 +01:00
match_free(current_match);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
match_init(current_match);
Bugfix: Free old criteria matching window list (Thanks piroko)
2012-01-27 22:47:55 +01:00
while (!TAILQ_EMPTY(&owindows)) {
ow = TAILQ_FIRST(&owindows);
TAILQ_REMOVE(&owindows, ow, owindows);
free(ow);
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
TAILQ_INIT(&owindows);
/* copy all_cons */
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(con, &all_cons, all_cons) {
Bugfix: Free old criteria matching window list (Thanks piroko)
2012-01-27 22:47:55 +01:00
ow = smalloc(sizeof(owindow));
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
ow->con = con;
TAILQ_INSERT_TAIL(&owindows, ow, owindows);
}
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* A match specification just finished (the closing square bracket was found),
* so we filter the list of owindows.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_criteria_match_windows(I3_CMD) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
owindow *next, *current;
DLOG("match specification finished, matching...\n");
/* copy the old list head to iterate through it and start with a fresh
* list which will contain only matching windows */
struct owindows_head old = owindows;
TAILQ_INIT(&owindows);
for (next = TAILQ_FIRST(&old); next != TAILQ_END(&old);) {
/* make a copy of the next pointer and advance the pointer to the
* next element as we are going to invalidate the element’s
* next/prev pointers by calling TAILQ_INSERT_TAIL later */
current = next;
next = TAILQ_NEXT(next, owindows);
DLOG("checking if con %p / %s matches\n", current->con, current->con->name);
if (current_match->con_id != NULL) {
if (current_match->con_id == current->con) {
DLOG("matches container!\n");
TAILQ_INSERT_TAIL(&owindows, current, owindows);
Free owindow when no con_id match or window This memory leak is related to matching on con_id or matching when the container has a null window. In that case, windows that do not match would leak the owindow struct.
2014-03-19 09:56:34 +01:00
} else {
DLOG("doesnt match\n");
free(current);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
} else if (current_match->mark != NULL && current->con->mark != NULL &&
regex_matches(current_match->mark, current->con->mark)) {
DLOG("match by mark\n");
TAILQ_INSERT_TAIL(&owindows, current, owindows);
} else {
Free owindow when no con_id match or window This memory leak is related to matching on con_id or matching when the container has a null window. In that case, windows that do not match would leak the owindow struct.
2014-03-19 09:56:34 +01:00
if (current->con->window && match_matches_window(current_match, current->con->window)) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matches window!\n");
TAILQ_INSERT_TAIL(&owindows, current, owindows);
} else {
DLOG("doesnt match\n");
free(current);
}
}
}
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
}
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Interprets a ctype=cvalue pair and adds it to the current match
* specification.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_criteria_add(I3_CMD, char *ctype, char *cvalue) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("ctype=*%s*, cvalue=*%s*\n", ctype, cvalue);
if (strcmp(ctype, "class") == 0) {
current_match->class = regex_new(cvalue);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
if (strcmp(ctype, "instance") == 0) {
current_match->instance = regex_new(cvalue);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
if (strcmp(ctype, "window_role") == 0) {
display swallows criteria in placeholder windows
2013-12-15 11:25:58 +01:00
current_match->window_role = regex_new(cvalue);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
if (strcmp(ctype, "con_id") == 0) {
char *end;
long parsed = strtol(cvalue, &end, 10);
if (parsed == LONG_MIN ||
parsed == LONG_MAX ||
parsed < 0 ||
(end && *end != '\0')) {
ELOG("Could not parse con id \"%s\"\n", cvalue);
} else {
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
current_match->con_id = (Con *)parsed;
replace remaining printf()s with D?LOG fixes #1252
2014-06-08 21:56:14 +02:00
DLOG("id as int = %p\n", current_match->con_id);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
if (strcmp(ctype, "id") == 0) {
char *end;
long parsed = strtol(cvalue, &end, 10);
if (parsed == LONG_MIN ||
parsed == LONG_MAX ||
parsed < 0 ||
(end && *end != '\0')) {
ELOG("Could not parse window id \"%s\"\n", cvalue);
} else {
current_match->id = parsed;
replace remaining printf()s with D?LOG fixes #1252
2014-06-08 21:56:14 +02:00
DLOG("window id as int = %d\n", current_match->id);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
if (strcmp(ctype, "con_mark") == 0) {
current_match->mark = regex_new(cvalue);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
if (strcmp(ctype, "title") == 0) {
current_match->title = regex_new(cvalue);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Implement urgency flag matcher Currently it supports the following options: "oldest": match the first window that triggered an urgent event "latest": match the last window that triggered an urgent event
2012-01-25 00:00:27 +01:00
if (strcmp(ctype, "urgent") == 0) {
if (strcasecmp(cvalue, "latest") == 0 ||
strcasecmp(cvalue, "newest") == 0 ||
strcasecmp(cvalue, "recent") == 0 ||
strcasecmp(cvalue, "last") == 0) {
current_match->urgent = U_LATEST;
} else if (strcasecmp(cvalue, "oldest") == 0 ||
strcasecmp(cvalue, "first") == 0) {
current_match->urgent = U_OLDEST;
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Implement urgency flag matcher Currently it supports the following options: "oldest": match the first window that triggered an urgent event "latest": match the last window that triggered an urgent event
2012-01-25 00:00:27 +01:00
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
ELOG("Unknown criterion: %s\n", ctype);
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'move [window|container] [to] workspace
Add a new command 'move to workspace current' Added a new command 'move to workspace current' which can be used with criteria to move a window to the current workspace.
2012-05-09 23:45:12 +02:00
* next|prev|next_on_output|prev_on_output|current'.
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_move_con_to_workspace(I3_CMD, char *which) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
owindow *current;
DLOG("which=%s\n", which);
Fix 'move to workspace' when used with criteria When moving window from other (not current) workspace to another workspace with criteria we should stay on current workspace. And we should exit early when criteria was specified but didn't match any window.
2012-05-09 23:43:21 +02:00
/* We have nothing to move:
* when criteria was specified but didn't match any window or
* when criteria wasn't specified and we don't have any window focused. */
if ((!match_is_empty(current_match) && TAILQ_EMPTY(&owindows)) ||
Implement moving workspaces as if they're regular containers
2012-09-28 19:54:24 +02:00
(match_is_empty(current_match) && focused->type == CT_WORKSPACE &&
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
!con_has_children(focused))) {
Fix 'move to workspace' when used with criteria When moving window from other (not current) workspace to another workspace with criteria we should stay on current workspace. And we should exit early when criteria was specified but didn't match any window.
2012-05-09 23:43:21 +02:00
ysuccess(false);
return;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
HANDLE_EMPTY_MATCH;
/* get the workspace */
Con *ws;
if (strcmp(which, "next") == 0)
ws = workspace_next();
else if (strcmp(which, "prev") == 0)
ws = workspace_prev();
else if (strcmp(which, "next_on_output") == 0)
ws = workspace_next_on_output();
else if (strcmp(which, "prev_on_output") == 0)
ws = workspace_prev_on_output();
Add a new command 'move to workspace current' Added a new command 'move to workspace current' which can be used with criteria to move a window to the current workspace.
2012-05-09 23:45:12 +02:00
else if (strcmp(which, "current") == 0)
ws = con_get_workspace(focused);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
else {
ELOG("BUG: called with which=%s\n", which);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
con_move_to_workspace(current->con, ws, true, false);
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
fixes #776 this implements both the "move container to workspace back_and_forth" command and movements to the same workspace when auto_back_and_forth is set. it includes documentation and test suite additions by michael. it also simplifies the workspace_show_by_name function (making use of workspace_get accepting NULL pointers).
2012-09-04 10:51:18 +02:00
/**
* Implementation of 'move [window|container] [to] workspace back_and_forth'.
*
*/
void cmd_move_con_to_workspace_back_and_forth(I3_CMD) {
owindow *current;
Con *ws;
ws = workspace_back_and_forth_get();
if (ws == NULL) {
reduce some yajl boilerplate This patch introduces a yerror() macro in src/commands.c and also removes some unused yajl helper macros from src/config_directives.c. Signed-off-by: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
2013-09-25 23:17:38 +02:00
yerror("No workspace was previously active.");
fixes #776 this implements both the "move container to workspace back_and_forth" command and movements to the same workspace when auto_back_and_forth is set. it includes documentation and test suite additions by michael. it also simplifies the workspace_show_by_name function (making use of workspace_get accepting NULL pointers).
2012-09-04 10:51:18 +02:00
return;
}
HANDLE_EMPTY_MATCH;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
fixes #776 this implements both the "move container to workspace back_and_forth" command and movements to the same workspace when auto_back_and_forth is set. it includes documentation and test suite additions by michael. it also simplifies the workspace_show_by_name function (making use of workspace_get accepting NULL pointers).
2012-09-04 10:51:18 +02:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
con_move_to_workspace(current->con, ws, true, false);
}
cmd_output->needs_tree_render = true;
// XXX: default reply for now, make this a better reply
ysuccess(true);
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'move [window|container] [to] workspace <name>'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_move_con_to_workspace_name(I3_CMD, char *name) {
Make all workspaces starting with "__" internal Workspaces won't work properly if they start with "__", so reserve that namespace altogether. Disallow renaming workspaces to reserved namespace and using reserved namespace in configuration. Fixes #1209.
2014-04-30 11:12:22 +02:00
if (strncasecmp(name, "__", strlen("__")) == 0) {
improve error messages for i3-internal workspace names
2014-05-03 15:02:51 +02:00
LOG("You cannot move containers to i3-internal workspaces (\"%s\").\n", name);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
owindow *current;
Fix 'move to workspace' when used with criteria When moving window from other (not current) workspace to another workspace with criteria we should stay on current workspace. And we should exit early when criteria was specified but didn't match any window.
2012-05-09 23:43:21 +02:00
/* We have nothing to move:
* when criteria was specified but didn't match any window or
* when criteria wasn't specified and we don't have any window focused. */
implement error messages when moving to another ws fails (Thanks eeemsi) fixes #769
2012-08-13 01:57:39 +02:00
if (!match_is_empty(current_match) && TAILQ_EMPTY(&owindows)) {
ELOG("No windows match your criteria, cannot move.\n");
ysuccess(false);
return;
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
} else if (match_is_empty(current_match) && focused->type == CT_WORKSPACE &&
!con_has_children(focused)) {
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
LOG("should move window to workspace %s\n", name);
/* get the workspace */
Workspace command number selection If a `workspace {N}` or `move to workspace {N}` command is given with N as a plain number, the workspace of this number is selected for the context of the command if one exists and there is no workspace with a name that exactly matches N.
2014-06-22 18:24:26 +02:00
Con *ws = NULL;
Con *output = NULL;
/* first look for a workspace with this name */
TAILQ_FOREACH(output, &(croot->nodes_head), nodes) {
GREP_FIRST(ws, output_get_content(output), !strcasecmp(child->name, name));
}
/* if the name is plain digits, we interpret this as a "workspace number"
* command */
if (!ws && name_is_digits(name)) {
long parsed_num = ws_name_to_number(name);
TAILQ_FOREACH(output, &(croot->nodes_head), nodes) {
GREP_FIRST(ws, output_get_content(output),
child->num == parsed_num);
}
}
/* if no workspace was found, make a new one */
if (!ws)
ws = workspace_get(name, NULL);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
fixes #776 this implements both the "move container to workspace back_and_forth" command and movements to the same workspace when auto_back_and_forth is set. it includes documentation and test suite additions by michael. it also simplifies the workspace_show_by_name function (making use of workspace_get accepting NULL pointers).
2012-09-04 10:51:18 +02:00
ws = maybe_auto_back_and_forth_workspace(ws);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
HANDLE_EMPTY_MATCH;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
con_move_to_workspace(current->con, ws, true, false);
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
/*
Make "[move] workspace number" accept a default ws name after the ws number
2012-08-31 20:19:27 +02:00
* Implementation of 'move [window|container] [to] workspace number <name>'.
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
*
*/
void cmd_move_con_to_workspace_number(I3_CMD, char *which) {
owindow *current;
Fix 'move to workspace' when used with criteria When moving window from other (not current) workspace to another workspace with criteria we should stay on current workspace. And we should exit early when criteria was specified but didn't match any window.
2012-05-09 23:43:21 +02:00
/* We have nothing to move:
* when criteria was specified but didn't match any window or
* when criteria wasn't specified and we don't have any window focused. */
if ((!match_is_empty(current_match) && TAILQ_EMPTY(&owindows)) ||
Implement moving workspaces as if they're regular containers
2012-09-28 19:54:24 +02:00
(match_is_empty(current_match) && focused->type == CT_WORKSPACE &&
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
!con_has_children(focused))) {
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
return;
}
fix a few warnings/places where the clang static analyzer complains
2012-08-05 16:34:38 +02:00
LOG("should move window to workspace %s\n", which);
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
/* get the workspace */
Fix warning: properly initialize 'workspace' variable
2012-04-08 20:45:49 +02:00
Con *output, *workspace = NULL;
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
Consistently parse workspace numbers Use ws_name_to_number() to parse workspace numbers where this transformation takes place.
2014-06-22 17:12:51 +02:00
long parsed_num = ws_name_to_number(which);
if (parsed_num == -1) {
Make "[move] workspace number" accept a default ws name after the ws number
2012-08-31 20:19:27 +02:00
LOG("Could not parse initial part of \"%s\" as a number.\n", which);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
// TODO: better error message
reduce some yajl boilerplate This patch introduces a yerror() macro in src/commands.c and also removes some unused yajl helper macros from src/config_directives.c. Signed-off-by: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
2013-09-25 23:17:38 +02:00
yerror("Could not parse number");
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
return;
}
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
GREP_FIRST(workspace, output_get_content(output),
child->num == parsed_num);
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
if (!workspace) {
Create ws in "move workspace number n" if not existing fixes #729
2012-08-20 12:36:10 +02:00
workspace = workspace_get(which, NULL);
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
}
fixes #776 this implements both the "move container to workspace back_and_forth" command and movements to the same workspace when auto_back_and_forth is set. it includes documentation and test suite additions by michael. it also simplifies the workspace_show_by_name function (making use of workspace_get accepting NULL pointers).
2012-09-04 10:51:18 +02:00
workspace = maybe_auto_back_and_forth_workspace(workspace);
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
HANDLE_EMPTY_MATCH;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
con_move_to_workspace(current->con, workspace, true, false);
}
cmd_output->needs_tree_render = true;
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Implement 'move [container|window] to workspace number <number>'
2012-04-08 20:33:46 +02:00
}
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
static void cmd_resize_floating(I3_CMD, char *way, char *direction, Con *floating_con, int px) {
LOG("floating resize\n");
Bugfix: Don’t move floating windows when their size constraints forbid resizing (Thanks aksr) fixes #883
2012-11-27 09:26:31 +01:00
Rect old_rect = floating_con->rect;
Ensure that resize will take place even if pixel is smaller than size increments. fixes #1011
2013-04-15 20:30:22 +02:00
Con *focused_con = con_descend_focused(floating_con);
/* ensure that resize will take place even if pixel increment is smaller than
* height increment or width increment.
* fixes #1011 */
if (strcmp(direction, "up") == 0 || strcmp(direction, "down") == 0 ||
strcmp(direction, "height") == 0) {
if (px < 0)
px = (-px < focused_con->height_increment) ? -focused_con->height_increment : px;
else
px = (px < focused_con->height_increment) ? focused_con->height_increment : px;
} else if (strcmp(direction, "left") == 0 || strcmp(direction, "right") == 0) {
if (px < 0)
px = (-px < focused_con->width_increment) ? -focused_con->width_increment : px;
else
px = (px < focused_con->width_increment) ? focused_con->width_increment : px;
}
Bugfix: Don’t move floating windows when their size constraints forbid resizing (Thanks aksr) fixes #883
2012-11-27 09:26:31 +01:00
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
if (strcmp(direction, "up") == 0) {
floating_con->rect.height += px;
fix resizing floating windows by height When resizing floating windows, changing the height was not correctly handled. This commit fixes that and adds testcases for shrinking and growing the width and height of floating windows.
2012-08-18 15:25:00 +02:00
} else if (strcmp(direction, "down") == 0 || strcmp(direction, "height") == 0) {
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
floating_con->rect.height += px;
} else if (strcmp(direction, "left") == 0) {
floating_con->rect.width += px;
} else {
floating_con->rect.width += px;
}
The command to resize a floating window now checks the minimum and maximum size.
2012-11-22 05:15:49 +01:00
code style fixes for the previous commit • our function names use underscores • rewrote the function’s comment • function comments must be in the source _and_ in the header • no blank lines after function signatures
2012-11-25 20:55:49 +01:00
floating_check_size(floating_con);
Bugfix: Don’t move floating windows when their size constraints forbid resizing (Thanks aksr) fixes #883
2012-11-27 09:26:31 +01:00
/* Did we actually resize anything or did the size constraints prevent us?
* If we could not resize, exit now to not move the window. */
if (memcmp(&old_rect, &(floating_con->rect), sizeof(Rect)) == 0)
return;
if (strcmp(direction, "up") == 0) {
Obey WM_SIZE_HINTS's resize increments in floating
2013-02-08 17:41:41 +01:00
floating_con->rect.y -= (floating_con->rect.height - old_rect.height);
Bugfix: Don’t move floating windows when their size constraints forbid resizing (Thanks aksr) fixes #883
2012-11-27 09:26:31 +01:00
} else if (strcmp(direction, "left") == 0) {
Obey WM_SIZE_HINTS's resize increments in floating
2013-02-08 17:41:41 +01:00
floating_con->rect.x -= (floating_con->rect.width - old_rect.width);
Bugfix: Don’t move floating windows when their size constraints forbid resizing (Thanks aksr) fixes #883
2012-11-27 09:26:31 +01:00
}
Always auto center on 'scratchpad show' if window hasn't been repositioned by the user This change ensures a scratchpad window is still centered on the screen if it has first been shown on another screen of a different resolution. Moving or resizing the scratchpad manually disables this behavior.
2012-09-24 21:14:40 +02:00
/* If this is a scratchpad window, don't auto center it from now on. */
if (floating_con->scratchpad_state == SCRATCHPAD_FRESH)
floating_con->scratchpad_state = SCRATCHPAD_CHANGED;
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
}
Make the resize command honor criteria (Thanks Tblue) fixes #816
2012-09-28 20:36:25 +02:00
static bool cmd_resize_tiling_direction(I3_CMD, Con *current, char *way, char *direction, int ppt) {
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
LOG("tiling resize\n");
Fix keyboard and mouse resize in nested containers fixes #1084 fixes #1085
2013-09-24 15:46:58 +02:00
Con *second = NULL;
Con *first = current;
direction_t search_direction;
if (!strcmp(direction, "left"))
search_direction = D_LEFT;
else if (!strcmp(direction, "right"))
search_direction = D_RIGHT;
else if (!strcmp(direction, "up"))
search_direction = D_UP;
else
search_direction = D_DOWN;
bool res = resize_find_tiling_participants(&first, &second, search_direction);
if (!res) {
LOG("No second container in this direction found.\n");
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Bugfix: Fix duplicate return value for 'resize' command
2012-07-22 21:25:38 +02:00
return false;
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
}
resizing: traverse containers up properly (+test) (Thanks oblique) In certain situations (when you have a h-split within a h-split) you couldn’t properly resize previously. This commit makes the resize command properly traverse up the containers. fixes #754
2012-07-22 21:37:26 +02:00
Fix keyboard and mouse resize in nested containers fixes #1084 fixes #1085
2013-09-24 15:46:58 +02:00
/* get the default percentage */
int children = con_num_children(first->parent);
LOG("ins. %d children\n", children);
double percentage = 1.0 / children;
LOG("default percentage = %f\n", percentage);
/* resize */
LOG("second->percent = %f\n", second->percent);
LOG("first->percent before = %f\n", first->percent);
if (first->percent == 0.0)
first->percent = percentage;
if (second->percent == 0.0)
second->percent = percentage;
double new_first_percent = first->percent + ((double)ppt / 100.0);
double new_second_percent = second->percent - ((double)ppt / 100.0);
LOG("new_first_percent = %f\n", new_first_percent);
LOG("new_second_percent = %f\n", new_second_percent);
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
/* Ensure that the new percentages are positive and greater than
* 0.05 to have a reasonable minimum size. */
Fix keyboard and mouse resize in nested containers fixes #1084 fixes #1085
2013-09-24 15:46:58 +02:00
if (definitelyGreaterThan(new_first_percent, 0.05, DBL_EPSILON) &&
definitelyGreaterThan(new_second_percent, 0.05, DBL_EPSILON)) {
first->percent += ((double)ppt / 100.0);
second->percent -= ((double)ppt / 100.0);
LOG("first->percent after = %f\n", first->percent);
LOG("second->percent after = %f\n", second->percent);
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
} else {
LOG("Not resizing, already at minimum size\n");
}
Bugfix: Fix duplicate return value for 'resize' command
2012-07-22 21:25:38 +02:00
return true;
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
}
Make the resize command honor criteria (Thanks Tblue) fixes #816
2012-09-28 20:36:25 +02:00
static bool cmd_resize_tiling_width_height(I3_CMD, Con *current, char *way, char *direction, int ppt) {
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
LOG("width/height resize\n");
/* get the appropriate current container (skip stacked/tabbed cons) */
while (current->parent->layout == L_STACKED ||
current->parent->layout == L_TABBED)
current = current->parent;
/* Then further go up until we find one with the matching orientation. */
orientation_t search_orientation =
(strcmp(direction, "width") == 0 ? HORIZ : VERT);
while (current->type != CT_WORKSPACE &&
current->type != CT_FLOATING_CON &&
Introduce splith/splitv layouts, remove orientation With this commit, the "default" layout is replaced by the splith and splitv layouts. splith is equivalent to default with orientation horizontal and splitv is equivalent to default with orientation vertical. The "split h" and "split v" commands continue to work as before, they split the current container and you will end up in a split container with layout splith (after "split h") or splitv (after "split v"). To change a splith container into a splitv container, use either "layout splitv" or "layout toggle split". The latter command is used in the default config as mod+l (previously "layout default"). In case you have "layout default" in your config file, it is recommended to just replace it by "layout toggle split", which will work as "layout default" did before when pressing it once, but toggle between horizontal/vertical when pressing it repeatedly. The rationale behind this commit is that it’s cleaner to have all parameters that influence how windows are rendered in the layout itself rather than having a special parameter in combination with only one layout. This enables us to change existing split containers in all cases without breaking existing features (see ticket #464). Also, users should feel more confident about whether they are actually splitting or just changing an existing split container now. As a nice side-effect, this commit brings back the "layout toggle" feature we once had in i3 version 3 (see the userguide). AFAIK, it is safe to use in-place restart to upgrade into versions after this commit (switching to an older version will break your layout, though). Fixes #464
2012-08-04 03:04:00 +02:00
con_orientation(current->parent) != search_orientation)
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
current = current->parent;
/* get the default percentage */
int children = con_num_children(current->parent);
LOG("ins. %d children\n", children);
double percentage = 1.0 / children;
LOG("default percentage = %f\n", percentage);
Introduce splith/splitv layouts, remove orientation With this commit, the "default" layout is replaced by the splith and splitv layouts. splith is equivalent to default with orientation horizontal and splitv is equivalent to default with orientation vertical. The "split h" and "split v" commands continue to work as before, they split the current container and you will end up in a split container with layout splith (after "split h") or splitv (after "split v"). To change a splith container into a splitv container, use either "layout splitv" or "layout toggle split". The latter command is used in the default config as mod+l (previously "layout default"). In case you have "layout default" in your config file, it is recommended to just replace it by "layout toggle split", which will work as "layout default" did before when pressing it once, but toggle between horizontal/vertical when pressing it repeatedly. The rationale behind this commit is that it’s cleaner to have all parameters that influence how windows are rendered in the layout itself rather than having a special parameter in combination with only one layout. This enables us to change existing split containers in all cases without breaking existing features (see ticket #464). Also, users should feel more confident about whether they are actually splitting or just changing an existing split container now. As a nice side-effect, this commit brings back the "layout toggle" feature we once had in i3 version 3 (see the userguide). AFAIK, it is safe to use in-place restart to upgrade into versions after this commit (switching to an older version will break your layout, though). Fixes #464
2012-08-04 03:04:00 +02:00
orientation_t orientation = con_orientation(current->parent);
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
if ((orientation == HORIZ &&
strcmp(direction, "height") == 0) ||
(orientation == VERT &&
strcmp(direction, "width") == 0)) {
LOG("You cannot resize in that direction. Your focus is in a %s split container currently.\n",
(orientation == HORIZ ? "horizontal" : "vertical"));
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Bugfix: Fix duplicate return value for 'resize' command
2012-07-22 21:25:38 +02:00
return false;
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
}
if (children == 1) {
LOG("This is the only container, cannot resize.\n");
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Bugfix: Fix duplicate return value for 'resize' command
2012-07-22 21:25:38 +02:00
return false;
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
}
/* Ensure all the other children have a percentage set. */
Con *child;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(child, &(current->parent->nodes_head), nodes) {
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
LOG("child->percent = %f (child %p)\n", child->percent, child);
if (child->percent == 0.0)
child->percent = percentage;
}
double new_current_percent = current->percent + ((double)ppt / 100.0);
double subtract_percent = ((double)ppt / 100.0) / (children - 1);
LOG("new_current_percent = %f\n", new_current_percent);
LOG("subtract_percent = %f\n", subtract_percent);
/* Ensure that the new percentages are positive and greater than
* 0.05 to have a reasonable minimum size. */
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(child, &(current->parent->nodes_head), nodes) {
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
if (child == current)
continue;
if (!definitelyGreaterThan(child->percent - subtract_percent, 0.05, DBL_EPSILON)) {
LOG("Not resizing, already at minimum size (child %p would end up with a size of %.f\n", child, child->percent - subtract_percent);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Bugfix: Fix duplicate return value for 'resize' command
2012-07-22 21:25:38 +02:00
return false;
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
}
}
if (!definitelyGreaterThan(new_current_percent, 0.05, DBL_EPSILON)) {
LOG("Not resizing, already at minimum size\n");
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Bugfix: Fix duplicate return value for 'resize' command
2012-07-22 21:25:38 +02:00
return false;
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
}
current->percent += ((double)ppt / 100.0);
LOG("current->percent after = %f\n", current->percent);
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(child, &(current->parent->nodes_head), nodes) {
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
if (child == current)
continue;
child->percent -= subtract_percent;
LOG("child->percent after (%p) = %f\n", child, child->percent);
}
Bugfix: Fix duplicate return value for 'resize' command
2012-07-22 21:25:38 +02:00
return true;
Implement resize <grow|shrink> <width|height>, use it in the default config Fixes: #576
2012-04-08 15:59:49 +02:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'resize grow|shrink <direction> [<px> px] [or <ppt> ppt]'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_resize(I3_CMD, char *way, char *direction, char *resize_px, char *resize_ppt) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
/* resize <grow|shrink> <direction> [<px> px] [or <ppt> ppt] */
DLOG("resizing in way %s, direction %s, px %s or ppt %s\n", way, direction, resize_px, resize_ppt);
// 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
int px = atoi(resize_px);
int ppt = atoi(resize_ppt);
if (strcmp(way, "shrink") == 0) {
px *= -1;
ppt *= -1;
}
Make the resize command honor criteria (Thanks Tblue) fixes #816
2012-09-28 20:36:25 +02:00
HANDLE_EMPTY_MATCH;
owindow *current;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Bugfix: don't try to resize docks by command cmd_resize does not implement a method to resize dock clients. A command like `[instance=".*"] resize grow width 160 px or 16 ppt` when a dock client matched would crash i3. fixes #1201
2014-03-15 03:59:08 +01:00
/* Don't handle dock windows (issue #1201) */
Bugfix: resize window check should check for null When checking the window type for a resize command, first check to see if the window property is null before checking whether or not it is a dock window. The window may be null in the case it is a branch container. fixes #1220
2014-04-18 20:14:22 +02:00
if (current->con->window && current->con->window->dock) {
Bugfix: don't try to resize docks by command cmd_resize does not implement a method to resize dock clients. A command like `[instance=".*"] resize grow width 160 px or 16 ppt` when a dock client matched would crash i3. fixes #1201
2014-03-15 03:59:08 +01:00
DLOG("This is a dock window. Not resizing (con = %p)\n)", current->con);
continue;
}
Make the resize command honor criteria (Thanks Tblue) fixes #816
2012-09-28 20:36:25 +02:00
Con *floating_con;
if ((floating_con = con_inside_floating(current->con))) {
cmd_resize_floating(current_match, cmd_output, way, direction, floating_con, px);
Bugfix: Fix duplicate return value for 'resize' command
2012-07-22 21:25:38 +02:00
} else {
Make the resize command honor criteria (Thanks Tblue) fixes #816
2012-09-28 20:36:25 +02:00
if (strcmp(direction, "width") == 0 ||
strcmp(direction, "height") == 0) {
if (!cmd_resize_tiling_width_height(current_match, cmd_output, current->con, way, direction, ppt))
return;
} else {
if (!cmd_resize_tiling_direction(current_match, cmd_output, current->con, way, direction, ppt))
return;
}
Bugfix: Fix duplicate return value for 'resize' command
2012-07-22 21:25:38 +02:00
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
Implement variable border widths for pixel/normal fixes #325
2012-09-24 01:14:00 +02:00
* Implementation of 'border normal|none|1pixel|toggle|pixel'.
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
*
*/
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
void cmd_border(I3_CMD, char *border_style_str, char *border_width) {
Implement variable border widths for pixel/normal fixes #325
2012-09-24 01:14:00 +02:00
DLOG("border style should be changed to %s with border width %s\n", border_style_str, border_width);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
owindow *current;
HANDLE_EMPTY_MATCH;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
int border_style = current->con->border_style;
Implement variable border widths for pixel/normal fixes #325
2012-09-24 01:14:00 +02:00
char *end;
int tmp_border_width = -1;
tmp_border_width = strtol(border_width, &end, 10);
if (end == border_width) {
/* no valid digits found */
tmp_border_width = -1;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
if (strcmp(border_style_str, "toggle") == 0) {
border_style++;
border_style %= 3;
Implement variable border widths for pixel/normal fixes #325
2012-09-24 01:14:00 +02:00
if (border_style == BS_NORMAL)
Fix 'border toggle' (it "skipped" 1px border) (Thanks joepd) fixes #818
2012-09-28 19:29:14 +02:00
tmp_border_width = 2;
Implement variable border widths for pixel/normal fixes #325
2012-09-24 01:14:00 +02:00
else if (border_style == BS_NONE)
Fix 'border toggle' (it "skipped" 1px border) (Thanks joepd) fixes #818
2012-09-28 19:29:14 +02:00
tmp_border_width = 0;
Implement variable border widths for pixel/normal fixes #325
2012-09-24 01:14:00 +02:00
else if (border_style == BS_PIXEL)
Fix 'border toggle' (it "skipped" 1px border) (Thanks joepd) fixes #818
2012-09-28 19:29:14 +02:00
tmp_border_width = 1;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
} else {
if (strcmp(border_style_str, "normal") == 0)
border_style = BS_NORMAL;
Implement variable border widths for pixel/normal fixes #325
2012-09-24 01:14:00 +02:00
else if (strcmp(border_style_str, "pixel") == 0)
border_style = BS_PIXEL;
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
else if (strcmp(border_style_str, "1pixel") == 0) {
Implement variable border widths for pixel/normal fixes #325
2012-09-24 01:14:00 +02:00
border_style = BS_PIXEL;
tmp_border_width = 1;
} else if (strcmp(border_style_str, "none") == 0)
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
border_style = BS_NONE;
else {
ELOG("BUG: called with border_style=%s\n", border_style_str);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
}
Implement variable border widths for pixel/normal fixes #325
2012-09-24 01:14:00 +02:00
con_set_border_style(current->con, border_style, tmp_border_width);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'nop <comment>'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_nop(I3_CMD, char *comment) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
LOG("-------------------------------------------------\n");
LOG(" NOP: %s\n", comment);
LOG("-------------------------------------------------\n");
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'append_layout <path>'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_append_layout(I3_CMD, char *path) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
LOG("Appending layout \"%s\"\n", path);
Bugfix: properly restore workspace containers (Thanks vals) fixes #1306
2014-07-15 10:15:04 +02:00
json_content_t content = json_determine_content(path);
LOG("JSON content = %d\n", content);
if (content == JSON_CONTENT_UNKNOWN) {
ELOG("Could not determine the contents of \"%s\", not loading.\n", path);
ysuccess(false);
return;
}
layout restore: create and render placeholder windows This is not entirely done yet, but TODO entries are placed in the code where appropriate.
2013-12-14 22:49:33 +01:00
Con *parent = focused;
Bugfix: properly restore workspace containers (Thanks vals) fixes #1306
2014-07-15 10:15:04 +02:00
if (content == JSON_CONTENT_WORKSPACE) {
parent = output_get_content(con_get_output(parent));
} else {
/* We need to append the layout to a split container, since a leaf
* container must not have any children (by definition).
* Note that we explicitly check for workspaces, since they are okay for
* this purpose, but con_accepts_window() returns false for workspaces. */
while (parent->type != CT_WORKSPACE && !con_accepts_window(parent))
parent = parent->parent;
}
DLOG("Appending to parent=%p instead of focused=%p\n", parent, focused);
return parse errors via IPC for append_layout
2014-01-04 21:39:13 +01:00
char *errormsg = NULL;
layout restoring: append at the nearest split container (or workspace) (Thanks chris) Before this commit, leaf containers (such as terminal emulators) would get children appended, which is not intended. fixes #1223
2014-04-18 20:30:27 +02:00
tree_append_json(parent, path, &errormsg);
return parse errors via IPC for append_layout
2014-01-04 21:39:13 +01:00
if (errormsg != NULL) {
yerror(errormsg);
free(errormsg);
/* Note that we continue executing since tree_append_json() has
* side-effects — user-provided layouts can be partly valid, partly
* invalid, leading to half of the placeholder containers being
* created. */
} else {
ysuccess(true);
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
layout restore: create and render placeholder windows This is not entirely done yet, but TODO entries are placed in the code where appropriate.
2013-12-14 22:49:33 +01:00
// XXX: This is a bit of a kludge. Theoretically, render_con(parent,
// false); should be enough, but when sending 'workspace 4; append_layout
// /tmp/foo.json', the needs_tree_render == true of the workspace command
// is not executed yet and will be batched with append_layout’s
// needs_tree_render after the parser finished. We should check if that is
// necessary at all.
render_con(croot, false);
restore_open_placeholder_windows(parent);
Bugfix: properly restore workspace containers (Thanks vals) fixes #1306
2014-07-15 10:15:04 +02:00
if (content == JSON_CONTENT_WORKSPACE)
ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"restored\"}");
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'workspace next|prev|next_on_output|prev_on_output'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_workspace(I3_CMD, char *which) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Con *ws;
DLOG("which=%s\n", which);
Prevent workspace change during global fullscreen While in global fullscreen, the workspace could be changed leaving the fullscreen container still visible on top but losing its focus.
2014-11-29 18:22:56 +01:00
if (con_get_fullscreen_con(croot, CF_GLOBAL)) {
LOG("Cannot switch workspace while in global fullscreen\n");
ysuccess(false);
return;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
if (strcmp(which, "next") == 0)
ws = workspace_next();
else if (strcmp(which, "prev") == 0)
ws = workspace_prev();
else if (strcmp(which, "next_on_output") == 0)
ws = workspace_next_on_output();
else if (strcmp(which, "prev_on_output") == 0)
ws = workspace_prev_on_output();
else {
ELOG("BUG: called with which=%s\n", which);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
workspace_show(ws);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Implement 'workspace number <number>' to switch to named workspaces
2012-04-08 19:17:46 +02:00
/*
Make "[move] workspace number" accept a default ws name after the ws number
2012-08-31 20:19:27 +02:00
* Implementation of 'workspace number <name>'
Implement 'workspace number <number>' to switch to named workspaces
2012-04-08 19:17:46 +02:00
*
*/
void cmd_workspace_number(I3_CMD, char *which) {
Fix warning: properly initialize 'workspace' variable
2012-04-08 20:45:49 +02:00
Con *output, *workspace = NULL;
Implement 'workspace number <number>' to switch to named workspaces
2012-04-08 19:17:46 +02:00
Prevent workspace change during global fullscreen While in global fullscreen, the workspace could be changed leaving the fullscreen container still visible on top but losing its focus.
2014-11-29 18:22:56 +01:00
if (con_get_fullscreen_con(croot, CF_GLOBAL)) {
LOG("Cannot switch workspace while in global fullscreen\n");
ysuccess(false);
return;
}
Consistently parse workspace numbers Use ws_name_to_number() to parse workspace numbers where this transformation takes place.
2014-06-22 17:12:51 +02:00
long parsed_num = ws_name_to_number(which);
if (parsed_num == -1) {
Make "[move] workspace number" accept a default ws name after the ws number
2012-08-31 20:19:27 +02:00
LOG("Could not parse initial part of \"%s\" as a number.\n", which);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
// TODO: better error message
reduce some yajl boilerplate This patch introduces a yerror() macro in src/commands.c and also removes some unused yajl helper macros from src/config_directives.c. Signed-off-by: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
2013-09-25 23:17:38 +02:00
yerror("Could not parse number");
Implement 'workspace number <number>' to switch to named workspaces
2012-04-08 19:17:46 +02:00
return;
}
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
GREP_FIRST(workspace, output_get_content(output),
child->num == parsed_num);
Implement 'workspace number <number>' to switch to named workspaces
2012-04-08 19:17:46 +02:00
if (!workspace) {
fix a few warnings/places where the clang static analyzer complains
2012-08-05 16:34:38 +02:00
LOG("There is no workspace with number %ld, creating a new one.\n", parsed_num);
bugfix: less differentiation between named and numbered workspaces calling workspace by number now also checks for switching back and forth and creates a new workspace if no workspace starting with that number is found also removed the obsolete tree_render() in favor of setting cmd_output->needs_tree_render to true
2012-05-02 16:05:27 +02:00
ysuccess(true);
workspace_show_by_name(which);
cmd_output->needs_tree_render = true;
Implement 'workspace number <number>' to switch to named workspaces
2012-04-08 19:17:46 +02:00
return;
}
Fix 'back and forth' in 'workspace number' for named ws
2012-08-22 17:49:22 +02:00
if (maybe_back_and_forth(cmd_output, workspace->name))
bugfix: less differentiation between named and numbered workspaces calling workspace by number now also checks for switching back and forth and creates a new workspace if no workspace starting with that number is found also removed the obsolete tree_render() in favor of setting cmd_output->needs_tree_render to true
2012-05-02 16:05:27 +02:00
return;
Implement 'workspace number <number>' to switch to named workspaces
2012-04-08 19:17:46 +02:00
workspace_show(workspace);
cmd_output->needs_tree_render = true;
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Implement 'workspace number <number>' to switch to named workspaces
2012-04-08 19:17:46 +02:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'workspace back_and_forth'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_workspace_back_and_forth(I3_CMD) {
Prevent workspace change during global fullscreen While in global fullscreen, the workspace could be changed leaving the fullscreen container still visible on top but losing its focus.
2014-11-29 18:22:56 +01:00
if (con_get_fullscreen_con(croot, CF_GLOBAL)) {
LOG("Cannot switch workspace while in global fullscreen\n");
ysuccess(false);
return;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
workspace_back_and_forth();
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'workspace <name>'
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_workspace_name(I3_CMD, char *name) {
Make all workspaces starting with "__" internal Workspaces won't work properly if they start with "__", so reserve that namespace altogether. Disallow renaming workspaces to reserved namespace and using reserved namespace in configuration. Fixes #1209.
2014-04-30 11:12:22 +02:00
if (strncasecmp(name, "__", strlen("__")) == 0) {
improve error messages for i3-internal workspace names
2014-05-03 15:02:51 +02:00
LOG("You cannot switch to the i3-internal workspaces (\"%s\").\n", name);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Prevent workspace change during global fullscreen While in global fullscreen, the workspace could be changed leaving the fullscreen container still visible on top but losing its focus.
2014-11-29 18:22:56 +01:00
if (con_get_fullscreen_con(croot, CF_GLOBAL)) {
LOG("Cannot switch workspace while in global fullscreen\n");
ysuccess(false);
return;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("should switch to workspace %s\n", name);
maybe_back_and_forth now sets render_tree
2012-05-02 22:27:41 +02:00
if (maybe_back_and_forth(cmd_output, name))
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
return;
Workspace command number selection If a `workspace {N}` or `move to workspace {N}` command is given with N as a plain number, the workspace of this number is selected for the context of the command if one exists and there is no workspace with a name that exactly matches N.
2014-06-22 18:24:26 +02:00
Con *ws = NULL;
Con *output = NULL;
/* first look for a workspace with this name */
TAILQ_FOREACH(output, &(croot->nodes_head), nodes) {
GREP_FIRST(ws, output_get_content(output), !strcasecmp(child->name, name));
}
/* if the name is only digits, we interpret this as a "workspace number"
* command */
if (!ws && name_is_digits(name)) {
long parsed_num = ws_name_to_number(name);
TAILQ_FOREACH(output, &(croot->nodes_head), nodes) {
GREP_FIRST(ws, output_get_content(output),
child->num == parsed_num);
}
}
/* if no workspace was found, make a new one */
if (!ws)
ws = workspace_get(name, NULL);
workspace_show(ws);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'mark <mark>'
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_mark(I3_CMD, char *mark) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("Clearing all windows which have that mark first\n");
Con *con;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(con, &all_cons, all_cons) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
if (con->mark && strcmp(con->mark, mark) == 0)
FREE(con->mark);
}
DLOG("marking window with str %s\n", mark);
owindow *current;
HANDLE_EMPTY_MATCH;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
current->con->mark = sstrdup(mark);
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
implement unmark command
2013-07-16 00:33:14 +02:00
/*
* Implementation of 'unmark [mark]'
*
*/
void cmd_unmark(I3_CMD, char *mark) {
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
if (mark == NULL) {
Con *con;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(con, &all_cons, all_cons) {
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
FREE(con->mark);
}
DLOG("removed all window marks");
} else {
Con *con;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(con, &all_cons, all_cons) {
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
if (con->mark && strcmp(con->mark, mark) == 0)
FREE(con->mark);
}
DLOG("removed window mark %s\n", mark);
implement unmark command
2013-07-16 00:33:14 +02:00
}
cmd_output->needs_tree_render = true;
// XXX: default reply for now, make this a better reply
ysuccess(true);
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'mode <string>'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_mode(I3_CMD, char *mode) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("mode=%s\n", mode);
switch_mode(mode);
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'move [window|container] [to] output <str>'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_move_con_to_output(I3_CMD, char *name) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
owindow *current;
DLOG("should move window to output %s\n", name);
HANDLE_EMPTY_MATCH;
/* get the output */
Output *current_output = NULL;
Output *output;
// TODO: fix the handling of criteria
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows)
current_output = get_output_of_con(current->con);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
assert(current_output != NULL);
// TODO: clean this up with commands.spec as soon as we switched away from the lex/yacc command parser
if (strcasecmp(name, "up") == 0)
wrap when moving things to outputs with direction
2013-01-25 00:02:09 +01:00
output = get_output_next_wrap(D_UP, current_output);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
else if (strcasecmp(name, "down") == 0)
wrap when moving things to outputs with direction
2013-01-25 00:02:09 +01:00
output = get_output_next_wrap(D_DOWN, current_output);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
else if (strcasecmp(name, "left") == 0)
wrap when moving things to outputs with direction
2013-01-25 00:02:09 +01:00
output = get_output_next_wrap(D_LEFT, current_output);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
else if (strcasecmp(name, "right") == 0)
wrap when moving things to outputs with direction
2013-01-25 00:02:09 +01:00
output = get_output_next_wrap(D_RIGHT, current_output);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
else
output = get_output_by_name(name);
if (!output) {
LOG("No such output found.\n");
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
/* get visible workspace on output */
Con *ws = NULL;
GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
if (!ws) {
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
con_move_to_workspace(current->con, ws, true, false);
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'floating enable|disable|toggle'
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_floating(I3_CMD, char *floating_mode) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
owindow *current;
DLOG("floating_mode=%s\n", floating_mode);
HANDLE_EMPTY_MATCH;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
if (strcmp(floating_mode, "toggle") == 0) {
DLOG("should toggle mode\n");
toggle_floating_mode(current->con, false);
} else {
DLOG("should switch mode to %s\n", floating_mode);
if (strcmp(floating_mode, "enable") == 0) {
floating_enable(current->con, false);
} else {
floating_disable(current->con, false);
}
}
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'move workspace to [output] <str>'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_move_workspace_to_output(I3_CMD, char *name) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("should move workspace to output %s\n", name);
HANDLE_EMPTY_MATCH;
owindow *current;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Fix output retrieval for floating cons When focusing/moving to outputs, the method of getting the correct output for a given container fails if the container in question is floating and only partially mapped on an output screen. This patch introduces a fail-safe retrieval of the output for any container.
2013-10-22 13:17:23 +02:00
Output *current_output = get_output_of_con(current->con);
Fix a crash when the current output cannot be determined (Thanks Tucos) This is only a cosmetical change though, the fix for the root cause can be found in the commits following this one.
2012-08-04 15:19:11 +02:00
if (!current_output) {
ELOG("Cannot get current output. This is a bug in i3.\n");
ysuccess(false);
return;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Output *output = get_output_from_string(current_output, name);
if (!output) {
Fix a crash when the current output cannot be determined (Thanks Tucos) This is only a cosmetical change though, the fix for the root cause can be found in the commits following this one.
2012-08-04 15:19:11 +02:00
ELOG("Could not get output from string \"%s\"\n", name);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Con *content = output_get_content(output->con);
LOG("got output %p with content %p\n", output, content);
Close empty workspaces after cross-output move (+test) (Thanks chrysn) fixes #795
2012-09-22 19:03:19 +02:00
Con *previously_visible_ws = TAILQ_FIRST(&(content->nodes_head));
LOG("Previously visible workspace = %p / %s\n", previously_visible_ws, previously_visible_ws->name);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Con *ws = con_get_workspace(current->con);
LOG("should move workspace %p / %s\n", ws, ws->name);
Close empty workspaces after cross-output move (+test) (Thanks chrysn) fixes #795
2012-09-22 19:03:19 +02:00
bool workspace_was_visible = workspace_is_visible(ws);
If moving the last ws, create a new one in its place. This seems better than refusing to move the last workspace.
2012-01-14 23:09:09 +01:00
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
if (con_num_children(ws->parent) == 1) {
If moving the last ws, create a new one in its place. This seems better than refusing to move the last workspace.
2012-01-14 23:09:09 +01:00
LOG("Creating a new workspace to replace \"%s\" (last on its output).\n", ws->name);
/* check if we can find a workspace assigned to this output */
bool used_assignment = false;
struct Workspace_Assignment *assignment;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(assignment, &ws_assignments, ws_assignments) {
If moving the last ws, create a new one in its place. This seems better than refusing to move the last workspace.
2012-01-14 23:09:09 +01:00
if (strcmp(assignment->output, current_output->name) != 0)
continue;
/* check if this workspace is already attached to the tree */
Con *workspace = NULL, *out;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(out, &(croot->nodes_head), nodes)
GREP_FIRST(workspace, output_get_content(out),
!strcasecmp(child->name, assignment->name));
If moving the last ws, create a new one in its place. This seems better than refusing to move the last workspace.
2012-01-14 23:09:09 +01:00
if (workspace != NULL)
continue;
/* so create the workspace referenced to by this assignment */
LOG("Creating workspace from assignment %s.\n", assignment->name);
workspace_get(assignment->name, NULL);
used_assignment = true;
break;
}
/* if we couldn't create the workspace using an assignment, create
* it on the output */
if (!used_assignment)
create_workspace_on_output(current_output, ws->parent);
/* notify the IPC listeners */
ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"init\"}");
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Bugfix: with one ws per output, don’t crash on cross-output moves (Thanks moju) fixes #827
2012-09-28 23:04:37 +02:00
DLOG("Detaching\n");
If moving the last ws, create a new one in its place. This seems better than refusing to move the last workspace.
2012-01-14 23:09:09 +01:00
Fix the coords of floating cons when moving workspaces. Fixes floating containers seemingly showing up in the wrong workspace after moving workspaces containing floating containers. We must *always* fix the coordinates of floating containers when moving workspaces across outputs. That's because the coordinates of floating containers are *not* relative to the workspaces.
2012-01-29 19:22:43 +01:00
/* detach from the old output and attach to the new output */
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Con *old_content = ws->parent;
con_detach(ws);
if (workspace_was_visible) {
/* The workspace which we just detached was visible, so focus
* the next one in the focus-stack. */
Con *focus_ws = TAILQ_FIRST(&(old_content->focus_head));
LOG("workspace was visible, focusing %p / %s now\n", focus_ws, focus_ws->name);
workspace_show(focus_ws);
}
con_attach(ws, content, false);
Fix the coords of floating cons when moving workspaces. Fixes floating containers seemingly showing up in the wrong workspace after moving workspaces containing floating containers. We must *always* fix the coordinates of floating containers when moving workspaces across outputs. That's because the coordinates of floating containers are *not* relative to the workspaces.
2012-01-29 19:22:43 +01:00
/* fix the coordinates of the floating containers */
Con *floating_con;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(floating_con, &(ws->floating_head), floating_windows)
floating_fix_coordinates(floating_con, &(old_content->rect), &(content->rect));
Fix the coords of floating cons when moving workspaces. Fixes floating containers seemingly showing up in the wrong workspace after moving workspaces containing floating containers. We must *always* fix the coordinates of floating containers when moving workspaces across outputs. That's because the coordinates of floating containers are *not* relative to the workspaces.
2012-01-29 19:22:43 +01:00
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"move\"}");
if (workspace_was_visible) {
/* Focus the moved workspace on the destination output. */
workspace_show(ws);
}
Close empty workspaces after cross-output move (+test) (Thanks chrysn) fixes #795
2012-09-22 19:03:19 +02:00
Bugfix: with one ws per output, don’t crash on cross-output moves (Thanks moju) fixes #827
2012-09-28 23:04:37 +02:00
/* NB: We cannot simply work with previously_visible_ws since it might
* have been cleaned up by workspace_show() already, depending on the
* focus order/number of other workspaces on the output.
* Instead, we loop through the available workspaces and only work with
* previously_visible_ws if we still find it. */
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(ws, &(content->nodes_head), nodes) {
Bugfix: with one ws per output, don’t crash on cross-output moves (Thanks moju) fixes #827
2012-09-28 23:04:37 +02:00
if (ws != previously_visible_ws)
continue;
/* Call the on_remove_child callback of the workspace which previously
* was visible on the destination output. Since it is no longer
* visible, it might need to get cleaned up. */
CALL(previously_visible_ws, on_remove_child);
break;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'split v|h|vertical|horizontal'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_split(I3_CMD, char *direction) {
con_set_layout: always use the parent container, handle workspaces properly Previously, in case 'layout stacked' (for example) had been called interactively, con_set_layout would be called with focused->parent, while with for_window, it’d be called on the actual matching container. This difference in behavior was the cause for the inability to use 'for_window [class="XTerm"] layout tabbed', which now works \o/, but more on that below. The change also allows us to handle the case of the user selecting a CT_WORKSPACE container properly, that is, by using the special case and creating a new split container on the workspace which gets all the contents, but a new layout. Now, before you are enthusiastic about the change and try to use for_window magic in your config file, keep in mind: The 'layout' command acts on the parent split container. That is, when using a line such as this one: for_window [class="XTerm"] layout tabbed …and opening an XTerm when on a workspace with one single other window, the whole workspace will be set tabbed (just as previously when you opened an XTerm and sent 'layout tabbed' manually). Therefore, to open XTerm in its own tabbed split container, you need to split before: for_window [class="XTerm"] split v, layout tabbed The comma here is important! It says that the second command should not be treated as an entirely unrelated command, but it should also relate the matching window (while it does work with a ';', that is prone to race-conditions and should be avoided). fixes #358
2012-09-05 00:22:38 +02:00
owindow *current;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
/* TODO: use matches */
LOG("splitting in direction %c\n", direction[0]);
con_set_layout: always use the parent container, handle workspaces properly Previously, in case 'layout stacked' (for example) had been called interactively, con_set_layout would be called with focused->parent, while with for_window, it’d be called on the actual matching container. This difference in behavior was the cause for the inability to use 'for_window [class="XTerm"] layout tabbed', which now works \o/, but more on that below. The change also allows us to handle the case of the user selecting a CT_WORKSPACE container properly, that is, by using the special case and creating a new split container on the workspace which gets all the contents, but a new layout. Now, before you are enthusiastic about the change and try to use for_window magic in your config file, keep in mind: The 'layout' command acts on the parent split container. That is, when using a line such as this one: for_window [class="XTerm"] layout tabbed …and opening an XTerm when on a workspace with one single other window, the whole workspace will be set tabbed (just as previously when you opened an XTerm and sent 'layout tabbed' manually). Therefore, to open XTerm in its own tabbed split container, you need to split before: for_window [class="XTerm"] split v, layout tabbed The comma here is important! It says that the second command should not be treated as an entirely unrelated command, but it should also relate the matching window (while it does work with a ';', that is prone to race-conditions and should be avoided). fixes #358
2012-09-05 00:22:38 +02:00
if (match_is_empty(current_match))
tree_split(focused, (direction[0] == 'v' ? VERT : HORIZ));
else {
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
con_set_layout: always use the parent container, handle workspaces properly Previously, in case 'layout stacked' (for example) had been called interactively, con_set_layout would be called with focused->parent, while with for_window, it’d be called on the actual matching container. This difference in behavior was the cause for the inability to use 'for_window [class="XTerm"] layout tabbed', which now works \o/, but more on that below. The change also allows us to handle the case of the user selecting a CT_WORKSPACE container properly, that is, by using the special case and creating a new split container on the workspace which gets all the contents, but a new layout. Now, before you are enthusiastic about the change and try to use for_window magic in your config file, keep in mind: The 'layout' command acts on the parent split container. That is, when using a line such as this one: for_window [class="XTerm"] layout tabbed …and opening an XTerm when on a workspace with one single other window, the whole workspace will be set tabbed (just as previously when you opened an XTerm and sent 'layout tabbed' manually). Therefore, to open XTerm in its own tabbed split container, you need to split before: for_window [class="XTerm"] split v, layout tabbed The comma here is important! It says that the second command should not be treated as an entirely unrelated command, but it should also relate the matching window (while it does work with a ';', that is prone to race-conditions and should be avoided). fixes #358
2012-09-05 00:22:38 +02:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
tree_split(current->con, (direction[0] == 'v' ? VERT : HORIZ));
}
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
spelling error: s/implementaiton/implementation/g
2012-10-24 07:58:03 +02:00
* Implementation of 'kill [window|client]'.
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_kill(I3_CMD, char *kill_mode_str) {
Implement a new parser for commands. (+test) On the rationale of using a custom parser instead of a lex/yacc one, see this quote from src/commands_parser.c: We use a hand-written parser instead of lex/yacc because our commands are easy for humans, not for computers. Thus, it’s quite hard to specify a context-free grammar for the commands. A PEG grammar would be easier, but there’s downsides to every PEG parser generator I have come accross so far. This parser is basically a state machine which looks for literals or strings and can push either on a stack. After identifying a literal or string, it will either transition to the current state, to a different state, or call a function (like cmd_move()). Special care has been taken that error messages are useful and the code is well testable (when compiled with -DTEST_PARSER it will output to stdout instead of actually calling any function). During the migration phase (I plan to completely switch to this parser before 4.2 will be released), the new parser will parse every command you send to i3 and save the resulting call stack. Then, the old parser will parse your input and actually execute the commands. Afterwards, both call stacks will be compared and any differences will be logged. The new parser works with 100% of the test suite and produces identical call stacks.
2012-01-14 20:53:29 +01:00
if (kill_mode_str == NULL)
kill_mode_str = "window";
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
owindow *current;
DLOG("kill_mode=%s\n", kill_mode_str);
int kill_mode;
Implement a new parser for commands. (+test) On the rationale of using a custom parser instead of a lex/yacc one, see this quote from src/commands_parser.c: We use a hand-written parser instead of lex/yacc because our commands are easy for humans, not for computers. Thus, it’s quite hard to specify a context-free grammar for the commands. A PEG grammar would be easier, but there’s downsides to every PEG parser generator I have come accross so far. This parser is basically a state machine which looks for literals or strings and can push either on a stack. After identifying a literal or string, it will either transition to the current state, to a different state, or call a function (like cmd_move()). Special care has been taken that error messages are useful and the code is well testable (when compiled with -DTEST_PARSER it will output to stdout instead of actually calling any function). During the migration phase (I plan to completely switch to this parser before 4.2 will be released), the new parser will parse every command you send to i3 and save the resulting call stack. Then, the old parser will parse your input and actually execute the commands. Afterwards, both call stacks will be compared and any differences will be logged. The new parser works with 100% of the test suite and produces identical call stacks.
2012-01-14 20:53:29 +01:00
if (strcmp(kill_mode_str, "window") == 0)
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
kill_mode = KILL_WINDOW;
else if (strcmp(kill_mode_str, "client") == 0)
kill_mode = KILL_CLIENT;
else {
ELOG("BUG: called with kill_mode=%s\n", kill_mode_str);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
/* check if the match is empty, not if the result is empty */
if (match_is_empty(current_match))
tree_close_con(kill_mode);
else {
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
tree_close(current->con, kill_mode, false, false);
}
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'exec [--no-startup-id] <command>'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_exec(I3_CMD, char *nosn, char *command) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
bool no_startup_id = (nosn != NULL);
DLOG("should execute %s, no_startup_id = %d\n", command, no_startup_id);
start_application(command, no_startup_id);
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'focus left|right|up|down'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_focus_direction(I3_CMD, char *direction) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("direction = *%s*\n", direction);
if (strcmp(direction, "left") == 0)
tree_next('p', HORIZ);
else if (strcmp(direction, "right") == 0)
tree_next('n', HORIZ);
else if (strcmp(direction, "up") == 0)
tree_next('p', VERT);
else if (strcmp(direction, "down") == 0)
tree_next('n', VERT);
else {
ELOG("Invalid focus direction (%s)\n", direction);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'focus tiling|floating|mode_toggle'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_focus_window_mode(I3_CMD, char *window_mode) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("window_mode = %s\n", window_mode);
Con *ws = con_get_workspace(focused);
Con *current;
if (ws != NULL) {
if (strcmp(window_mode, "mode_toggle") == 0) {
current = TAILQ_FIRST(&(ws->focus_head));
if (current != NULL && current->type == CT_FLOATING_CON)
window_mode = "tiling";
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
else
window_mode = "floating";
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &(ws->focus_head), focused) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
if ((strcmp(window_mode, "floating") == 0 && current->type != CT_FLOATING_CON) ||
(strcmp(window_mode, "tiling") == 0 && current->type == CT_FLOATING_CON))
continue;
con_focus(con_descend_focused(current));
break;
}
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'focus parent|child'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_focus_level(I3_CMD, char *level) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("level = %s\n", level);
Allow focus child/parent when in fullscreen. This is now restricted according to the already defined fullscreen focus constraints. Test case 157 was removed, as we don't prevent level up/down in fullscreen anymore. Those commands are properly tested in fullscreen by test case 156. Fixes: #612
2012-05-26 23:36:25 +02:00
bool success = false;
/* Focusing the parent can only be allowed if the newly
* focused container won't escape the fullscreen container. */
if (strcmp(level, "parent") == 0) {
if (focused && focused->parent) {
if (con_fullscreen_permits_focusing(focused->parent))
success = level_up();
else
Properly report errors in 'focus parent' (Thanks eeemsi) Also, make X11 errors debug log level only. They are harmless usually. fixes #762
2012-08-05 20:56:33 +02:00
ELOG("'focus parent': Currently in fullscreen, not going up\n");
Allow focus child/parent when in fullscreen. This is now restricted according to the already defined fullscreen focus constraints. Test case 157 was removed, as we don't prevent level up/down in fullscreen anymore. Those commands are properly tested in fullscreen by test case 156. Fixes: #612
2012-05-26 23:36:25 +02:00
}
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Allow focus child/parent when in fullscreen. This is now restricted according to the already defined fullscreen focus constraints. Test case 157 was removed, as we don't prevent level up/down in fullscreen anymore. Those commands are properly tested in fullscreen by test case 156. Fixes: #612
2012-05-26 23:36:25 +02:00
/* Focusing a child should always be allowed. */
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
else
success = level_down();
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Allow focus child/parent when in fullscreen. This is now restricted according to the already defined fullscreen focus constraints. Test case 157 was removed, as we don't prevent level up/down in fullscreen anymore. Those commands are properly tested in fullscreen by test case 156. Fixes: #612
2012-05-26 23:36:25 +02:00
cmd_output->needs_tree_render = success;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Allow focus child/parent when in fullscreen. This is now restricted according to the already defined fullscreen focus constraints. Test case 157 was removed, as we don't prevent level up/down in fullscreen anymore. Those commands are properly tested in fullscreen by test case 156. Fixes: #612
2012-05-26 23:36:25 +02:00
ysuccess(success);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'focus'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_focus(I3_CMD) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("current_match = %p\n", current_match);
if (match_is_empty(current_match)) {
ELOG("You have to specify which window/container should be focused.\n");
ELOG("Example: [class=\"urxvt\" title=\"irssi\"] focus\n");
reduce some yajl boilerplate This patch introduces a yerror() macro in src/commands.c and also removes some unused yajl helper macros from src/config_directives.c. Signed-off-by: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
2013-09-25 23:17:38 +02:00
yerror("You have to specify which window/container should be focused");
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Call scratchpad_show() when focusing scratchpad windows via criteria fixes #931
2013-01-25 16:10:37 +01:00
Con *__i3_scratch = workspace_get("__i3_scratch", NULL);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
int count = 0;
Allow focus w/ target when in fs in some cases. If the target is in a different workspace, there's no reason why we wouldn't allow the user to focus it. We already allow this when focusing a workspace, for example.
2012-04-21 21:34:25 +02:00
owindow *current;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Con *ws = con_get_workspace(current->con);
/* If no workspace could be found, this was a dock window.
* Just skip it, you cannot focus dock windows. */
if (!ws)
continue;
Refined the fullscreen focus constraints. Basically, a focus change can't escape a fullscreen container. The only exception is per-output fullscreen containers, as you should be able to focus a container in a different workspace in this case. This is an improvement on 4eab046e, now considering the difference between global and per-output fullscreen and taking the tree structure into account to determine what escaping the fullscreen container means. It only affects targeted focus commands in the form "for_window [...] focus", but it lays the foundation for forthcoming fixes to all other focus commands.
2012-05-26 22:37:45 +02:00
/* Check the fullscreen focus constraints. */
if (!con_fullscreen_permits_focusing(current->con)) {
LOG("Cannot change focus while in fullscreen mode (fullscreen rules).\n");
Allow focus w/ target when in fs in some cases. If the target is in a different workspace, there's no reason why we wouldn't allow the user to focus it. We already allow this when focusing a workspace, for example.
2012-04-21 21:34:25 +02:00
ysuccess(false);
return;
}
Call scratchpad_show() when focusing scratchpad windows via criteria fixes #931
2013-01-25 16:10:37 +01:00
/* In case this is a scratchpad window, call scratchpad_show(). */
if (ws == __i3_scratch) {
scratchpad_show(current->con);
count++;
/* While for the normal focus case we can change focus multiple
* times and only a single window ends up focused, we could show
* multiple scratchpad windows. So, rather break here. */
break;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
/* If the container is not on the current workspace,
* workspace_show() will switch to a different workspace and (if
* enabled) trigger a mouse pointer warp to the currently focused
* container (!) on the target workspace.
*
* Therefore, before calling workspace_show(), we make sure that
* 'current' will be focused on the workspace. However, we cannot
* just con_focus(current) because then the pointer will not be
* warped at all (the code thinks we are already there).
*
* So we focus 'current' to make it the currently focused window of
* the target workspace, then revert focus. */
Con *currently_focused = focused;
con_focus(current->con);
con_focus(currently_focused);
/* Now switch to the workspace, then focus */
workspace_show(ws);
LOG("focusing %p / %s\n", current->con, current->con->name);
con_focus(current->con);
count++;
}
if (count > 1)
LOG("WARNING: Your criteria for the focus command matches %d containers, "
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
"while only exactly one container can be focused at a time.\n",
count);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'fullscreen [global]'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_fullscreen(I3_CMD, char *fullscreen_mode) {
Implement a new parser for commands. (+test) On the rationale of using a custom parser instead of a lex/yacc one, see this quote from src/commands_parser.c: We use a hand-written parser instead of lex/yacc because our commands are easy for humans, not for computers. Thus, it’s quite hard to specify a context-free grammar for the commands. A PEG grammar would be easier, but there’s downsides to every PEG parser generator I have come accross so far. This parser is basically a state machine which looks for literals or strings and can push either on a stack. After identifying a literal or string, it will either transition to the current state, to a different state, or call a function (like cmd_move()). Special care has been taken that error messages are useful and the code is well testable (when compiled with -DTEST_PARSER it will output to stdout instead of actually calling any function). During the migration phase (I plan to completely switch to this parser before 4.2 will be released), the new parser will parse every command you send to i3 and save the resulting call stack. Then, the old parser will parse your input and actually execute the commands. Afterwards, both call stacks will be compared and any differences will be logged. The new parser works with 100% of the test suite and produces identical call stacks.
2012-01-14 20:53:29 +01:00
if (fullscreen_mode == NULL)
fullscreen_mode = "output";
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("toggling fullscreen, mode = %s\n", fullscreen_mode);
owindow *current;
HANDLE_EMPTY_MATCH;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Remove debug message when debugging is disabled More precisely, switch from printf to DLOG a "matching: * / *" message, like all the other "matching: * / *" messages.
2013-08-20 02:07:31 +02:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
Implement a new parser for commands. (+test) On the rationale of using a custom parser instead of a lex/yacc one, see this quote from src/commands_parser.c: We use a hand-written parser instead of lex/yacc because our commands are easy for humans, not for computers. Thus, it’s quite hard to specify a context-free grammar for the commands. A PEG grammar would be easier, but there’s downsides to every PEG parser generator I have come accross so far. This parser is basically a state machine which looks for literals or strings and can push either on a stack. After identifying a literal or string, it will either transition to the current state, to a different state, or call a function (like cmd_move()). Special care has been taken that error messages are useful and the code is well testable (when compiled with -DTEST_PARSER it will output to stdout instead of actually calling any function). During the migration phase (I plan to completely switch to this parser before 4.2 will be released), the new parser will parse every command you send to i3 and save the resulting call stack. Then, the old parser will parse your input and actually execute the commands. Afterwards, both call stacks will be compared and any differences will be logged. The new parser works with 100% of the test suite and produces identical call stacks.
2012-01-14 20:53:29 +01:00
con_toggle_fullscreen(current->con, (strcmp(fullscreen_mode, "global") == 0 ? CF_GLOBAL : CF_OUTPUT));
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'move <direction> [<pixels> [px]]'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_move_direction(I3_CMD, char *direction, char *move_px) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// 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
int px = atoi(move_px);
Make command `move [direction]` work with criteria A container selected with criteria should be moved with the `move [direction]` command, instead of this command always acting on the focused container.
2014-06-19 14:09:31 +02:00
owindow *current;
HANDLE_EMPTY_MATCH;
Con *initially_focused = focused;
fix src/commands.c with clang-format
2014-06-23 21:29:42 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Make command `move [direction]` work with criteria A container selected with criteria should be moved with the `move [direction]` command, instead of this command always acting on the focused container.
2014-06-19 14:09:31 +02:00
DLOG("moving in direction %s, px %s\n", direction, move_px);
if (con_is_floating(current->con)) {
DLOG("floating move with %d pixels\n", px);
Rect newrect = current->con->parent->rect;
if (strcmp(direction, "left") == 0) {
newrect.x -= px;
} else if (strcmp(direction, "right") == 0) {
newrect.x += px;
} else if (strcmp(direction, "up") == 0) {
newrect.y -= px;
} else if (strcmp(direction, "down") == 0) {
newrect.y += px;
}
floating_reposition(current->con->parent, newrect);
} else {
tree_move(current->con, (strcmp(direction, "right") == 0 ? D_RIGHT : (strcmp(direction, "left") == 0 ? D_LEFT : (strcmp(direction, "up") == 0 ? D_UP : D_DOWN))));
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
}
Make command `move [direction]` work with criteria A container selected with criteria should be moved with the `move [direction]` command, instead of this command always acting on the focused container.
2014-06-19 14:09:31 +02:00
/* the move command should not disturb focus */
if (focused != initially_focused)
con_focus(initially_focused);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
Introduce splith/splitv layouts, remove orientation With this commit, the "default" layout is replaced by the splith and splitv layouts. splith is equivalent to default with orientation horizontal and splitv is equivalent to default with orientation vertical. The "split h" and "split v" commands continue to work as before, they split the current container and you will end up in a split container with layout splith (after "split h") or splitv (after "split v"). To change a splith container into a splitv container, use either "layout splitv" or "layout toggle split". The latter command is used in the default config as mod+l (previously "layout default"). In case you have "layout default" in your config file, it is recommended to just replace it by "layout toggle split", which will work as "layout default" did before when pressing it once, but toggle between horizontal/vertical when pressing it repeatedly. The rationale behind this commit is that it’s cleaner to have all parameters that influence how windows are rendered in the layout itself rather than having a special parameter in combination with only one layout. This enables us to change existing split containers in all cases without breaking existing features (see ticket #464). Also, users should feel more confident about whether they are actually splitting or just changing an existing split container now. As a nice side-effect, this commit brings back the "layout toggle" feature we once had in i3 version 3 (see the userguide). AFAIK, it is safe to use in-place restart to upgrade into versions after this commit (switching to an older version will break your layout, though). Fixes #464
2012-08-04 03:04:00 +02:00
* Implementation of 'layout default|stacked|stacking|tabbed|splitv|splith'.
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_layout(I3_CMD, char *layout_str) {
Implement a new parser for commands. (+test) On the rationale of using a custom parser instead of a lex/yacc one, see this quote from src/commands_parser.c: We use a hand-written parser instead of lex/yacc because our commands are easy for humans, not for computers. Thus, it’s quite hard to specify a context-free grammar for the commands. A PEG grammar would be easier, but there’s downsides to every PEG parser generator I have come accross so far. This parser is basically a state machine which looks for literals or strings and can push either on a stack. After identifying a literal or string, it will either transition to the current state, to a different state, or call a function (like cmd_move()). Special care has been taken that error messages are useful and the code is well testable (when compiled with -DTEST_PARSER it will output to stdout instead of actually calling any function). During the migration phase (I plan to completely switch to this parser before 4.2 will be released), the new parser will parse every command you send to i3 and save the resulting call stack. Then, the old parser will parse your input and actually execute the commands. Afterwards, both call stacks will be compared and any differences will be logged. The new parser works with 100% of the test suite and produces identical call stacks.
2012-01-14 20:53:29 +01:00
if (strcmp(layout_str, "stacking") == 0)
layout_str = "stacked";
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
owindow *current;
Give layout enum a name: layout_t
2013-05-22 06:28:13 +02:00
layout_t layout;
Introduce splith/splitv layouts, remove orientation With this commit, the "default" layout is replaced by the splith and splitv layouts. splith is equivalent to default with orientation horizontal and splitv is equivalent to default with orientation vertical. The "split h" and "split v" commands continue to work as before, they split the current container and you will end up in a split container with layout splith (after "split h") or splitv (after "split v"). To change a splith container into a splitv container, use either "layout splitv" or "layout toggle split". The latter command is used in the default config as mod+l (previously "layout default"). In case you have "layout default" in your config file, it is recommended to just replace it by "layout toggle split", which will work as "layout default" did before when pressing it once, but toggle between horizontal/vertical when pressing it repeatedly. The rationale behind this commit is that it’s cleaner to have all parameters that influence how windows are rendered in the layout itself rather than having a special parameter in combination with only one layout. This enables us to change existing split containers in all cases without breaking existing features (see ticket #464). Also, users should feel more confident about whether they are actually splitting or just changing an existing split container now. As a nice side-effect, this commit brings back the "layout toggle" feature we once had in i3 version 3 (see the userguide). AFAIK, it is safe to use in-place restart to upgrade into versions after this commit (switching to an older version will break your layout, though). Fixes #464
2012-08-04 03:04:00 +02:00
/* default is a special case which will be handled in con_set_layout(). */
if (strcmp(layout_str, "default") == 0)
layout = L_DEFAULT;
else if (strcmp(layout_str, "stacked") == 0)
layout = L_STACKED;
else if (strcmp(layout_str, "tabbed") == 0)
layout = L_TABBED;
else if (strcmp(layout_str, "splitv") == 0)
layout = L_SPLITV;
else if (strcmp(layout_str, "splith") == 0)
layout = L_SPLITH;
fix a few warnings/places where the clang static analyzer complains
2012-08-05 16:34:38 +02:00
else {
ELOG("Unknown layout \"%s\", this is a mismatch between code and parser spec.\n", layout_str);
return;
}
Introduce splith/splitv layouts, remove orientation With this commit, the "default" layout is replaced by the splith and splitv layouts. splith is equivalent to default with orientation horizontal and splitv is equivalent to default with orientation vertical. The "split h" and "split v" commands continue to work as before, they split the current container and you will end up in a split container with layout splith (after "split h") or splitv (after "split v"). To change a splith container into a splitv container, use either "layout splitv" or "layout toggle split". The latter command is used in the default config as mod+l (previously "layout default"). In case you have "layout default" in your config file, it is recommended to just replace it by "layout toggle split", which will work as "layout default" did before when pressing it once, but toggle between horizontal/vertical when pressing it repeatedly. The rationale behind this commit is that it’s cleaner to have all parameters that influence how windows are rendered in the layout itself rather than having a special parameter in combination with only one layout. This enables us to change existing split containers in all cases without breaking existing features (see ticket #464). Also, users should feel more confident about whether they are actually splitting or just changing an existing split container now. As a nice side-effect, this commit brings back the "layout toggle" feature we once had in i3 version 3 (see the userguide). AFAIK, it is safe to use in-place restart to upgrade into versions after this commit (switching to an older version will break your layout, though). Fixes #464
2012-08-04 03:04:00 +02:00
DLOG("changing layout to %s (%d)\n", layout_str, layout);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
/* check if the match is empty, not if the result is empty */
if (match_is_empty(current_match))
con_set_layout: always use the parent container, handle workspaces properly Previously, in case 'layout stacked' (for example) had been called interactively, con_set_layout would be called with focused->parent, while with for_window, it’d be called on the actual matching container. This difference in behavior was the cause for the inability to use 'for_window [class="XTerm"] layout tabbed', which now works \o/, but more on that below. The change also allows us to handle the case of the user selecting a CT_WORKSPACE container properly, that is, by using the special case and creating a new split container on the workspace which gets all the contents, but a new layout. Now, before you are enthusiastic about the change and try to use for_window magic in your config file, keep in mind: The 'layout' command acts on the parent split container. That is, when using a line such as this one: for_window [class="XTerm"] layout tabbed …and opening an XTerm when on a workspace with one single other window, the whole workspace will be set tabbed (just as previously when you opened an XTerm and sent 'layout tabbed' manually). Therefore, to open XTerm in its own tabbed split container, you need to split before: for_window [class="XTerm"] split v, layout tabbed The comma here is important! It says that the second command should not be treated as an entirely unrelated command, but it should also relate the matching window (while it does work with a ';', that is prone to race-conditions and should be avoided). fixes #358
2012-09-05 00:22:38 +02:00
con_set_layout(focused, layout);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
else {
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
con_set_layout(current->con, layout);
}
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Introduce splith/splitv layouts, remove orientation With this commit, the "default" layout is replaced by the splith and splitv layouts. splith is equivalent to default with orientation horizontal and splitv is equivalent to default with orientation vertical. The "split h" and "split v" commands continue to work as before, they split the current container and you will end up in a split container with layout splith (after "split h") or splitv (after "split v"). To change a splith container into a splitv container, use either "layout splitv" or "layout toggle split". The latter command is used in the default config as mod+l (previously "layout default"). In case you have "layout default" in your config file, it is recommended to just replace it by "layout toggle split", which will work as "layout default" did before when pressing it once, but toggle between horizontal/vertical when pressing it repeatedly. The rationale behind this commit is that it’s cleaner to have all parameters that influence how windows are rendered in the layout itself rather than having a special parameter in combination with only one layout. This enables us to change existing split containers in all cases without breaking existing features (see ticket #464). Also, users should feel more confident about whether they are actually splitting or just changing an existing split container now. As a nice side-effect, this commit brings back the "layout toggle" feature we once had in i3 version 3 (see the userguide). AFAIK, it is safe to use in-place restart to upgrade into versions after this commit (switching to an older version will break your layout, though). Fixes #464
2012-08-04 03:04:00 +02:00
/*
* Implementation of 'layout toggle [all|split]'.
*
*/
void cmd_layout_toggle(I3_CMD, char *toggle_mode) {
owindow *current;
if (toggle_mode == NULL)
toggle_mode = "default";
DLOG("toggling layout (mode = %s)\n", toggle_mode);
/* check if the match is empty, not if the result is empty */
if (match_is_empty(current_match))
con_set_layout: always use the parent container, handle workspaces properly Previously, in case 'layout stacked' (for example) had been called interactively, con_set_layout would be called with focused->parent, while with for_window, it’d be called on the actual matching container. This difference in behavior was the cause for the inability to use 'for_window [class="XTerm"] layout tabbed', which now works \o/, but more on that below. The change also allows us to handle the case of the user selecting a CT_WORKSPACE container properly, that is, by using the special case and creating a new split container on the workspace which gets all the contents, but a new layout. Now, before you are enthusiastic about the change and try to use for_window magic in your config file, keep in mind: The 'layout' command acts on the parent split container. That is, when using a line such as this one: for_window [class="XTerm"] layout tabbed …and opening an XTerm when on a workspace with one single other window, the whole workspace will be set tabbed (just as previously when you opened an XTerm and sent 'layout tabbed' manually). Therefore, to open XTerm in its own tabbed split container, you need to split before: for_window [class="XTerm"] split v, layout tabbed The comma here is important! It says that the second command should not be treated as an entirely unrelated command, but it should also relate the matching window (while it does work with a ';', that is prone to race-conditions and should be avoided). fixes #358
2012-09-05 00:22:38 +02:00
con_toggle_layout(focused, toggle_mode);
Introduce splith/splitv layouts, remove orientation With this commit, the "default" layout is replaced by the splith and splitv layouts. splith is equivalent to default with orientation horizontal and splitv is equivalent to default with orientation vertical. The "split h" and "split v" commands continue to work as before, they split the current container and you will end up in a split container with layout splith (after "split h") or splitv (after "split v"). To change a splith container into a splitv container, use either "layout splitv" or "layout toggle split". The latter command is used in the default config as mod+l (previously "layout default"). In case you have "layout default" in your config file, it is recommended to just replace it by "layout toggle split", which will work as "layout default" did before when pressing it once, but toggle between horizontal/vertical when pressing it repeatedly. The rationale behind this commit is that it’s cleaner to have all parameters that influence how windows are rendered in the layout itself rather than having a special parameter in combination with only one layout. This enables us to change existing split containers in all cases without breaking existing features (see ticket #464). Also, users should feel more confident about whether they are actually splitting or just changing an existing split container now. As a nice side-effect, this commit brings back the "layout toggle" feature we once had in i3 version 3 (see the userguide). AFAIK, it is safe to use in-place restart to upgrade into versions after this commit (switching to an older version will break your layout, though). Fixes #464
2012-08-04 03:04:00 +02:00
else {
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Introduce splith/splitv layouts, remove orientation With this commit, the "default" layout is replaced by the splith and splitv layouts. splith is equivalent to default with orientation horizontal and splitv is equivalent to default with orientation vertical. The "split h" and "split v" commands continue to work as before, they split the current container and you will end up in a split container with layout splith (after "split h") or splitv (after "split v"). To change a splith container into a splitv container, use either "layout splitv" or "layout toggle split". The latter command is used in the default config as mod+l (previously "layout default"). In case you have "layout default" in your config file, it is recommended to just replace it by "layout toggle split", which will work as "layout default" did before when pressing it once, but toggle between horizontal/vertical when pressing it repeatedly. The rationale behind this commit is that it’s cleaner to have all parameters that influence how windows are rendered in the layout itself rather than having a special parameter in combination with only one layout. This enables us to change existing split containers in all cases without breaking existing features (see ticket #464). Also, users should feel more confident about whether they are actually splitting or just changing an existing split container now. As a nice side-effect, this commit brings back the "layout toggle" feature we once had in i3 version 3 (see the userguide). AFAIK, it is safe to use in-place restart to upgrade into versions after this commit (switching to an older version will break your layout, though). Fixes #464
2012-08-04 03:04:00 +02:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
con_toggle_layout(current->con, toggle_mode);
}
}
cmd_output->needs_tree_render = true;
// XXX: default reply for now, make this a better reply
ysuccess(true);
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
spelling error: s/implementaiton/implementation/g
2012-10-24 07:58:03 +02:00
* Implementation of 'exit'.
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_exit(I3_CMD) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
LOG("Exiting due to user command.\n");
delete ipc socket when exiting, cleanup tmpdir fixes #1253
2014-06-08 22:13:43 +02:00
ipc_shutdown();
unlink(config.ipc_socket_path);
Explicitly disconnect in the 'exit' command This fixes a race condition when running the tests. I think that the X11 server has more time to clean up the resources when we do an explicit disconnect. The symptom I was seeing was that sometimes, i3 couldn’t become the window manager on one of the Xdummy instances.
2012-06-29 23:13:25 +02:00
xcb_disconnect(conn);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
exit(0);
/* unreached */
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
spelling error: s/implementaiton/implementation/g
2012-10-24 07:58:03 +02:00
* Implementation of 'reload'.
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_reload(I3_CMD) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
LOG("reloading\n");
refactor both i3-nagbar starts into src/util.c With this change, libev >= 4 is a hard dependency. It should be present in all major linux distributions (even the latest ubuntu LTS).
2012-12-24 16:53:20 +01:00
kill_nagbar(&config_error_nagbar_pid, false);
kill_nagbar(&command_error_nagbar_pid, false);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
load_configuration(conn, NULL, true);
x_set_i3_atoms();
/* Send an IPC event just in case the ws names have changed */
ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"reload\"}");
introduced i3 command for changing the hidden state and the mode of i3bar The hidden_state and mode of each i3bar instance can now be controlled from within i3. Therefore, two new i3 command were introduced: _ bar hidden_state show|hide|toggle [<bar_id>] show: always show the bar hide: normal hide mode toggle: toggle between show and hide (individually for each bar) _ bar mode dock|hide|invisible|toggle [<bar_id>] hide,dock: like before invisible: always keep the bar hidden toggle: toggle between dock and hide (individually for each bar) This patch introduces a hidden_state ("hidden_state hide|show") in the barconfig, which indicates the current hidden_state of each i3bar instance. It only affects the bar when in hide mode. Additionally, a new invisible mode was introduced. In order to change the hidden_state or mode of the bar from i3, a barconfig-update event was introduced, for which a bar can subscribe and the bar then gets notified about the currently set hidden_state and mode in its barconfig. For convenience, an id field ("id <bar_id>") was added to the barconfig, where one can set the desired id for the corresponding bar. If the id is not specified, i3 will deterministically choose an id; otherwise, with the previous random approach for finding a new id, which is actually not shared with i3bar, as it would determine its id on startup, the event-subscription would be destroyed on reload. Still, this issue remains when manually changing the bar_id in the config and then reloading. fixes #833, #651
2013-05-25 14:30:00 +02:00
/* Send an update event for the barconfig just in case it has changed */
update_barconfig();
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
spelling error: s/implementaiton/implementation/g
2012-10-24 07:58:03 +02:00
* Implementation of 'restart'.
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_restart(I3_CMD) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
LOG("restarting i3\n");
cleanup temporary directory when restarting and not using XDG_RUNTIME_DIR fixes #1253
2014-06-11 09:17:43 +02:00
ipc_shutdown();
Bugfix: create the directory for storing the restart state (Thanks hjem) fixes #1303
2014-06-27 09:04:51 +02:00
unlink(config.ipc_socket_path);
cleanup temporary directory when restarting and not using XDG_RUNTIME_DIR fixes #1253
2014-06-11 09:17:43 +02:00
/* We need to call this manually since atexit handlers don’t get called
* when exec()ing */
purge_zerobyte_logfile();
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
i3_restart(false);
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
spelling error: s/implementaiton/implementation/g
2012-10-24 07:58:03 +02:00
* Implementation of 'open'.
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_open(I3_CMD) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
LOG("opening new container\n");
Con *con = tree_open_con(NULL, NULL);
Introduce splith/splitv layouts, remove orientation With this commit, the "default" layout is replaced by the splith and splitv layouts. splith is equivalent to default with orientation horizontal and splitv is equivalent to default with orientation vertical. The "split h" and "split v" commands continue to work as before, they split the current container and you will end up in a split container with layout splith (after "split h") or splitv (after "split v"). To change a splith container into a splitv container, use either "layout splitv" or "layout toggle split". The latter command is used in the default config as mod+l (previously "layout default"). In case you have "layout default" in your config file, it is recommended to just replace it by "layout toggle split", which will work as "layout default" did before when pressing it once, but toggle between horizontal/vertical when pressing it repeatedly. The rationale behind this commit is that it’s cleaner to have all parameters that influence how windows are rendered in the layout itself rather than having a special parameter in combination with only one layout. This enables us to change existing split containers in all cases without breaking existing features (see ticket #464). Also, users should feel more confident about whether they are actually splitting or just changing an existing split container now. As a nice side-effect, this commit brings back the "layout toggle" feature we once had in i3 version 3 (see the userguide). AFAIK, it is safe to use in-place restart to upgrade into versions after this commit (switching to an older version will break your layout, though). Fixes #464
2012-08-04 03:04:00 +02:00
con->layout = L_SPLITH;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
con_focus(con);
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
y(map_open);
ystr("success");
y(bool, true);
ystr("id");
y(integer, (long int)con);
y(map_close);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'focus output <output>'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_focus_output(I3_CMD, char *name) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
owindow *current;
DLOG("name = %s\n", name);
HANDLE_EMPTY_MATCH;
/* get the output */
Output *current_output = NULL;
Output *output;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows)
current_output = get_output_of_con(current->con);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
assert(current_output != NULL);
output = get_output_from_string(current_output, name);
if (!output) {
LOG("No such output found.\n");
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
/* get visible workspace on output */
Con *ws = NULL;
GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
if (!ws) {
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(false);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
return;
}
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
workspace_show(ws);
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
/*
* Implementation of 'move [window|container] [to] [absolute] position <px> [px] <px> [px]
*
*/
void cmd_move_window_to_position(I3_CMD, char *method, char *cx, char *cy) {
int x = atoi(cx);
int y = atoi(cy);
Make absolute floating move work with criteria Make commands of type `move [window|container] [to] [absolute] position <px> [px] <px> [px]` work with command selection criteria. fixes #1301
2014-07-01 08:12:28 +02:00
bool has_error = false;
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
Make absolute floating move work with criteria Make commands of type `move [window|container] [to] [absolute] position <px> [px] <px> [px]` work with command selection criteria. fixes #1301
2014-07-01 08:12:28 +02:00
owindow *current;
HANDLE_EMPTY_MATCH;
TAILQ_FOREACH(current, &owindows, owindows) {
if (!con_is_floating(current->con)) {
ELOG("Cannot change position. The window/container is not floating\n");
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
Make absolute floating move work with criteria Make commands of type `move [window|container] [to] [absolute] position <px> [px] <px> [px]` work with command selection criteria. fixes #1301
2014-07-01 08:12:28 +02:00
if (!has_error) {
yerror("Cannot change position of a window/container because it is not floating.");
has_error = true;
}
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
Make absolute floating move work with criteria Make commands of type `move [window|container] [to] [absolute] position <px> [px] <px> [px]` work with command selection criteria. fixes #1301
2014-07-01 08:12:28 +02:00
continue;
}
if (strcmp(method, "absolute") == 0) {
current->con->parent->rect.x = x;
current->con->parent->rect.y = y;
DLOG("moving to absolute position %d %d\n", x, y);
floating_maybe_reassign_ws(current->con->parent);
cmd_output->needs_tree_render = true;
}
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
Make absolute floating move work with criteria Make commands of type `move [window|container] [to] [absolute] position <px> [px] <px> [px]` work with command selection criteria. fixes #1301
2014-07-01 08:12:28 +02:00
if (strcmp(method, "position") == 0) {
Rect newrect = current->con->parent->rect;
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
Make absolute floating move work with criteria Make commands of type `move [window|container] [to] [absolute] position <px> [px] <px> [px]` work with command selection criteria. fixes #1301
2014-07-01 08:12:28 +02:00
DLOG("moving to position %d %d\n", x, y);
newrect.x = x;
newrect.y = y;
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
Make absolute floating move work with criteria Make commands of type `move [window|container] [to] [absolute] position <px> [px] <px> [px]` work with command selection criteria. fixes #1301
2014-07-01 08:12:28 +02:00
floating_reposition(current->con->parent, newrect);
}
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
}
// XXX: default reply for now, make this a better reply
Make absolute floating move work with criteria Make commands of type `move [window|container] [to] [absolute] position <px> [px] <px> [px]` work with command selection criteria. fixes #1301
2014-07-01 08:12:28 +02:00
if (!has_error)
ysuccess(true);
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
}
/*
* Implementation of 'move [window|container] [to] [absolute] position center
*
*/
void cmd_move_window_to_center(I3_CMD, char *method) {
if (!con_is_floating(focused)) {
ELOG("Cannot change position. The window/container is not floating\n");
reduce some yajl boilerplate This patch introduces a yerror() macro in src/commands.c and also removes some unused yajl helper macros from src/config_directives.c. Signed-off-by: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
2013-09-25 23:17:38 +02:00
yerror("Cannot change position. The window/container is not floating.");
Add missing return after error reporting.
2013-07-29 22:45:27 +02:00
return;
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
}
if (strcmp(method, "absolute") == 0) {
Rect *rect = &focused->parent->rect;
DLOG("moving to absolute center\n");
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
rect->x = croot->rect.width / 2 - rect->width / 2;
rect->y = croot->rect.height / 2 - rect->height / 2;
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
floating_maybe_reassign_ws(focused->parent);
cmd_output->needs_tree_render = true;
}
if (strcmp(method, "position") == 0) {
Rect *wsrect = &con_get_workspace(focused)->rect;
Rect newrect = focused->parent->rect;
DLOG("moving to center\n");
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
newrect.x = wsrect->width / 2 - newrect.width / 2;
newrect.y = wsrect->height / 2 - newrect.height / 2;
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
floating_reposition(focused->parent, newrect);
}
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Extends move command for floating windows
2012-03-23 13:39:17 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'move scratchpad'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_move_scratchpad(I3_CMD) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("should move window to scratchpad\n");
owindow *current;
HANDLE_EMPTY_MATCH;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
scratchpad_move(current->con);
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
add comments to src/commands.c
2012-01-27 23:32:40 +01:00
/*
* Implementation of 'scratchpad show'.
*
*/
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
void cmd_scratchpad_show(I3_CMD) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("should show scratchpad window\n");
owindow *current;
if (match_is_empty(current_match)) {
scratchpad_show(NULL);
} else {
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &owindows, owindows) {
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
DLOG("matching: %p / %s\n", current->con, current->con->name);
scratchpad_show(current->con);
}
}
Refactor the interface of commands.c This change has two implications: 1) tree_render() will now be called precisely once for input which consists of multiple commands (like "focus left; focus right"). Also, the caller of parse_command() has to call it. This makes us able to fix tickets such as ticket #608 (where multiple tree_render() calls are noticable). 2) The output of a command is now a JSON array of return values of the individual subcommands. In the case of "focus left; focus right", this is: [{"success":true}, {"success":true}] While this is incompatible with what i3 returned before, the return value of commands was undocumented and therefore not subject to our API stability.
2012-02-07 23:38:21 +01:00
cmd_output->needs_tree_render = true;
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
// XXX: default reply for now, make this a better reply
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Refactor the code out of src/cmdparse.y to src/commands.c This is the first step towards our new parser.
2012-01-14 16:02:30 +01:00
}
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
/*
introduce new command to rename focused workspace The corresponding command is 'rename workspace to <name>'. As a side-effect this fixes the command 'rename workspace 1 to to'. Signed-off-by: Michael Walle <michael@walle.cc>
2012-10-29 22:42:20 +01:00
* Implementation of 'rename workspace [<name>] to <name>'
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
*
*/
void cmd_rename_workspace(I3_CMD, char *old_name, char *new_name) {
Make all workspaces starting with "__" internal Workspaces won't work properly if they start with "__", so reserve that namespace altogether. Disallow renaming workspaces to reserved namespace and using reserved namespace in configuration. Fixes #1209.
2014-04-30 11:12:22 +02:00
if (strncasecmp(new_name, "__", strlen("__")) == 0) {
improve error messages for i3-internal workspace names
2014-05-03 15:02:51 +02:00
LOG("Cannot rename workspace to \"%s\": names starting with __ are i3-internal.", new_name);
Make all workspaces starting with "__" internal Workspaces won't work properly if they start with "__", so reserve that namespace altogether. Disallow renaming workspaces to reserved namespace and using reserved namespace in configuration. Fixes #1209.
2014-04-30 11:12:22 +02:00
ysuccess(false);
return;
}
introduce new command to rename focused workspace The corresponding command is 'rename workspace to <name>'. As a side-effect this fixes the command 'rename workspace 1 to to'. Signed-off-by: Michael Walle <michael@walle.cc>
2012-10-29 22:42:20 +01:00
if (old_name) {
LOG("Renaming workspace \"%s\" to \"%s\"\n", old_name, new_name);
} else {
LOG("Renaming current workspace to \"%s\"\n", new_name);
}
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
Con *output, *workspace = NULL;
introduce new command to rename focused workspace The corresponding command is 'rename workspace to <name>'. As a side-effect this fixes the command 'rename workspace 1 to to'. Signed-off-by: Michael Walle <michael@walle.cc>
2012-10-29 22:42:20 +01:00
if (old_name) {
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
GREP_FIRST(workspace, output_get_content(output),
!strcasecmp(child->name, old_name));
introduce new command to rename focused workspace The corresponding command is 'rename workspace to <name>'. As a side-effect this fixes the command 'rename workspace 1 to to'. Signed-off-by: Michael Walle <michael@walle.cc>
2012-10-29 22:42:20 +01:00
} else {
workspace = con_get_workspace(focused);
}
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
if (!workspace) {
// TODO: we should include the old workspace name here and use yajl for
// generating the reply.
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
// TODO: better error message
reduce some yajl boilerplate This patch introduces a yerror() macro in src/commands.c and also removes some unused yajl helper macros from src/config_directives.c. Signed-off-by: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
2013-09-25 23:17:38 +02:00
yerror("Old workspace not found");
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
return;
}
Con *check_dest = NULL;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(output, &(croot->nodes_head), nodes)
GREP_FIRST(check_dest, output_get_content(output),
!strcasecmp(child->name, new_name));
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
if (check_dest != NULL) {
// TODO: we should include the new workspace name here and use yajl for
// generating the reply.
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
// TODO: better error message
reduce some yajl boilerplate This patch introduces a yerror() macro in src/commands.c and also removes some unused yajl helper macros from src/config_directives.c. Signed-off-by: Vivien Didelot <vivien.didelot@savoirfairelinux.com>
2013-09-25 23:17:38 +02:00
yerror("New workspace already exists");
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
return;
}
/* Change the name and try to parse it as a number. */
FREE(workspace->name);
workspace->name = sstrdup(new_name);
Consistently parse workspace numbers Use ws_name_to_number() to parse workspace numbers where this transformation takes place.
2014-06-22 17:12:51 +02:00
workspace->num = ws_name_to_number(new_name);
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
LOG("num = %d\n", workspace->num);
/* By re-attaching, the sort order will be correct afterwards. */
Con *previously_focused = focused;
Con *parent = workspace->parent;
con_detach(workspace);
con_attach(workspace, parent, false);
/* Restore the previous focus since con_attach messes with the focus. */
con_focus(previously_focused);
cmd_output->needs_tree_render = true;
Send proper error messages upon parser failures, use yajl for generating command replies Fixes: #693
2012-05-02 22:01:50 +02:00
ysuccess(true);
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"rename\"}");
Implement EWMH desktop names Maintain the _NET_DESKTOP_NAMES property on the root window. http://standards.freedesktop.org/wm-spec/latest/ar01s03.html#idm140251368131760 > _NET_DESKTOP_NAMES > > _NET_DESKTOP_NAMES, UTF8_STRING[] > > The names of all virtual desktops. This is a list of NULL-terminated > strings in UTF-8 encoding [UTF8]. This property MAY be changed by a > Pager or the Window Manager at any time.
2014-06-23 23:44:24 +02:00
ewmh_update_desktop_names();
ewmh_update_desktop_viewport();
ewmh_update_current_desktop();
Implement 'rename workspace <old_name> to <new_name>'
2012-04-08 20:34:31 +02:00
}
introduced i3 command for changing the hidden state and the mode of i3bar The hidden_state and mode of each i3bar instance can now be controlled from within i3. Therefore, two new i3 command were introduced: _ bar hidden_state show|hide|toggle [<bar_id>] show: always show the bar hide: normal hide mode toggle: toggle between show and hide (individually for each bar) _ bar mode dock|hide|invisible|toggle [<bar_id>] hide,dock: like before invisible: always keep the bar hidden toggle: toggle between dock and hide (individually for each bar) This patch introduces a hidden_state ("hidden_state hide|show") in the barconfig, which indicates the current hidden_state of each i3bar instance. It only affects the bar when in hide mode. Additionally, a new invisible mode was introduced. In order to change the hidden_state or mode of the bar from i3, a barconfig-update event was introduced, for which a bar can subscribe and the bar then gets notified about the currently set hidden_state and mode in its barconfig. For convenience, an id field ("id <bar_id>") was added to the barconfig, where one can set the desired id for the corresponding bar. If the id is not specified, i3 will deterministically choose an id; otherwise, with the previous random approach for finding a new id, which is actually not shared with i3bar, as it would determine its id on startup, the event-subscription would be destroyed on reload. Still, this issue remains when manually changing the bar_id in the config and then reloading. fixes #833, #651
2013-05-25 14:30:00 +02:00
/*
* Implementation of 'bar mode dock|hide|invisible|toggle [<bar_id>]'
*
*/
bool cmd_bar_mode(char *bar_mode, char *bar_id) {
Initialize variables to prevent (false) warnings.
2013-08-18 18:12:19 +02:00
int mode = M_DOCK;
introduced i3 command for changing the hidden state and the mode of i3bar The hidden_state and mode of each i3bar instance can now be controlled from within i3. Therefore, two new i3 command were introduced: _ bar hidden_state show|hide|toggle [<bar_id>] show: always show the bar hide: normal hide mode toggle: toggle between show and hide (individually for each bar) _ bar mode dock|hide|invisible|toggle [<bar_id>] hide,dock: like before invisible: always keep the bar hidden toggle: toggle between dock and hide (individually for each bar) This patch introduces a hidden_state ("hidden_state hide|show") in the barconfig, which indicates the current hidden_state of each i3bar instance. It only affects the bar when in hide mode. Additionally, a new invisible mode was introduced. In order to change the hidden_state or mode of the bar from i3, a barconfig-update event was introduced, for which a bar can subscribe and the bar then gets notified about the currently set hidden_state and mode in its barconfig. For convenience, an id field ("id <bar_id>") was added to the barconfig, where one can set the desired id for the corresponding bar. If the id is not specified, i3 will deterministically choose an id; otherwise, with the previous random approach for finding a new id, which is actually not shared with i3bar, as it would determine its id on startup, the event-subscription would be destroyed on reload. Still, this issue remains when manually changing the bar_id in the config and then reloading. fixes #833, #651
2013-05-25 14:30:00 +02:00
bool toggle = false;
if (strcmp(bar_mode, "dock") == 0)
mode = M_DOCK;
else if (strcmp(bar_mode, "hide") == 0)
mode = M_HIDE;
else if (strcmp(bar_mode, "invisible") == 0)
mode = M_INVISIBLE;
else if (strcmp(bar_mode, "toggle") == 0)
toggle = true;
else {
ELOG("Unknown bar mode \"%s\", this is a mismatch between code and parser spec.\n", bar_mode);
return false;
}
bool changed_sth = false;
Barconfig *current = NULL;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &barconfigs, configs) {
introduced i3 command for changing the hidden state and the mode of i3bar The hidden_state and mode of each i3bar instance can now be controlled from within i3. Therefore, two new i3 command were introduced: _ bar hidden_state show|hide|toggle [<bar_id>] show: always show the bar hide: normal hide mode toggle: toggle between show and hide (individually for each bar) _ bar mode dock|hide|invisible|toggle [<bar_id>] hide,dock: like before invisible: always keep the bar hidden toggle: toggle between dock and hide (individually for each bar) This patch introduces a hidden_state ("hidden_state hide|show") in the barconfig, which indicates the current hidden_state of each i3bar instance. It only affects the bar when in hide mode. Additionally, a new invisible mode was introduced. In order to change the hidden_state or mode of the bar from i3, a barconfig-update event was introduced, for which a bar can subscribe and the bar then gets notified about the currently set hidden_state and mode in its barconfig. For convenience, an id field ("id <bar_id>") was added to the barconfig, where one can set the desired id for the corresponding bar. If the id is not specified, i3 will deterministically choose an id; otherwise, with the previous random approach for finding a new id, which is actually not shared with i3bar, as it would determine its id on startup, the event-subscription would be destroyed on reload. Still, this issue remains when manually changing the bar_id in the config and then reloading. fixes #833, #651
2013-05-25 14:30:00 +02:00
if (bar_id && strcmp(current->id, bar_id) != 0)
continue;
if (toggle)
mode = (current->mode + 1) % 2;
DLOG("Changing bar mode of bar_id '%s' to '%s (%d)'\n", current->id, bar_mode, mode);
current->mode = mode;
changed_sth = true;
if (bar_id)
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
break;
introduced i3 command for changing the hidden state and the mode of i3bar The hidden_state and mode of each i3bar instance can now be controlled from within i3. Therefore, two new i3 command were introduced: _ bar hidden_state show|hide|toggle [<bar_id>] show: always show the bar hide: normal hide mode toggle: toggle between show and hide (individually for each bar) _ bar mode dock|hide|invisible|toggle [<bar_id>] hide,dock: like before invisible: always keep the bar hidden toggle: toggle between dock and hide (individually for each bar) This patch introduces a hidden_state ("hidden_state hide|show") in the barconfig, which indicates the current hidden_state of each i3bar instance. It only affects the bar when in hide mode. Additionally, a new invisible mode was introduced. In order to change the hidden_state or mode of the bar from i3, a barconfig-update event was introduced, for which a bar can subscribe and the bar then gets notified about the currently set hidden_state and mode in its barconfig. For convenience, an id field ("id <bar_id>") was added to the barconfig, where one can set the desired id for the corresponding bar. If the id is not specified, i3 will deterministically choose an id; otherwise, with the previous random approach for finding a new id, which is actually not shared with i3bar, as it would determine its id on startup, the event-subscription would be destroyed on reload. Still, this issue remains when manually changing the bar_id in the config and then reloading. fixes #833, #651
2013-05-25 14:30:00 +02:00
}
if (bar_id && !changed_sth) {
DLOG("Changing bar mode of bar_id %s failed, bar_id not found.\n", bar_id);
return false;
}
return true;
}
/*
* Implementation of 'bar hidden_state hide|show|toggle [<bar_id>]'
*
*/
bool cmd_bar_hidden_state(char *bar_hidden_state, char *bar_id) {
Initialize variables to prevent (false) warnings.
2013-08-18 18:12:19 +02:00
int hidden_state = S_SHOW;
introduced i3 command for changing the hidden state and the mode of i3bar The hidden_state and mode of each i3bar instance can now be controlled from within i3. Therefore, two new i3 command were introduced: _ bar hidden_state show|hide|toggle [<bar_id>] show: always show the bar hide: normal hide mode toggle: toggle between show and hide (individually for each bar) _ bar mode dock|hide|invisible|toggle [<bar_id>] hide,dock: like before invisible: always keep the bar hidden toggle: toggle between dock and hide (individually for each bar) This patch introduces a hidden_state ("hidden_state hide|show") in the barconfig, which indicates the current hidden_state of each i3bar instance. It only affects the bar when in hide mode. Additionally, a new invisible mode was introduced. In order to change the hidden_state or mode of the bar from i3, a barconfig-update event was introduced, for which a bar can subscribe and the bar then gets notified about the currently set hidden_state and mode in its barconfig. For convenience, an id field ("id <bar_id>") was added to the barconfig, where one can set the desired id for the corresponding bar. If the id is not specified, i3 will deterministically choose an id; otherwise, with the previous random approach for finding a new id, which is actually not shared with i3bar, as it would determine its id on startup, the event-subscription would be destroyed on reload. Still, this issue remains when manually changing the bar_id in the config and then reloading. fixes #833, #651
2013-05-25 14:30:00 +02:00
bool toggle = false;
if (strcmp(bar_hidden_state, "hide") == 0)
hidden_state = S_HIDE;
else if (strcmp(bar_hidden_state, "show") == 0)
hidden_state = S_SHOW;
else if (strcmp(bar_hidden_state, "toggle") == 0)
toggle = true;
else {
ELOG("Unknown bar state \"%s\", this is a mismatch between code and parser spec.\n", bar_hidden_state);
return false;
}
bool changed_sth = false;
Barconfig *current = NULL;
clang-format-3.5 **/*.h **/*.c This should be the last commit that formats a big bunch of files. From here on, whenever I merge patches, I’ll run clang-format like described in the title.
2014-06-19 11:20:32 +02:00
TAILQ_FOREACH(current, &barconfigs, configs) {
introduced i3 command for changing the hidden state and the mode of i3bar The hidden_state and mode of each i3bar instance can now be controlled from within i3. Therefore, two new i3 command were introduced: _ bar hidden_state show|hide|toggle [<bar_id>] show: always show the bar hide: normal hide mode toggle: toggle between show and hide (individually for each bar) _ bar mode dock|hide|invisible|toggle [<bar_id>] hide,dock: like before invisible: always keep the bar hidden toggle: toggle between dock and hide (individually for each bar) This patch introduces a hidden_state ("hidden_state hide|show") in the barconfig, which indicates the current hidden_state of each i3bar instance. It only affects the bar when in hide mode. Additionally, a new invisible mode was introduced. In order to change the hidden_state or mode of the bar from i3, a barconfig-update event was introduced, for which a bar can subscribe and the bar then gets notified about the currently set hidden_state and mode in its barconfig. For convenience, an id field ("id <bar_id>") was added to the barconfig, where one can set the desired id for the corresponding bar. If the id is not specified, i3 will deterministically choose an id; otherwise, with the previous random approach for finding a new id, which is actually not shared with i3bar, as it would determine its id on startup, the event-subscription would be destroyed on reload. Still, this issue remains when manually changing the bar_id in the config and then reloading. fixes #833, #651
2013-05-25 14:30:00 +02:00
if (bar_id && strcmp(current->id, bar_id) != 0)
continue;
if (toggle)
hidden_state = (current->hidden_state + 1) % 2;
DLOG("Changing bar hidden_state of bar_id '%s' to '%s (%d)'\n", current->id, bar_hidden_state, hidden_state);
current->hidden_state = hidden_state;
changed_sth = true;
if (bar_id)
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
break;
introduced i3 command for changing the hidden state and the mode of i3bar The hidden_state and mode of each i3bar instance can now be controlled from within i3. Therefore, two new i3 command were introduced: _ bar hidden_state show|hide|toggle [<bar_id>] show: always show the bar hide: normal hide mode toggle: toggle between show and hide (individually for each bar) _ bar mode dock|hide|invisible|toggle [<bar_id>] hide,dock: like before invisible: always keep the bar hidden toggle: toggle between dock and hide (individually for each bar) This patch introduces a hidden_state ("hidden_state hide|show") in the barconfig, which indicates the current hidden_state of each i3bar instance. It only affects the bar when in hide mode. Additionally, a new invisible mode was introduced. In order to change the hidden_state or mode of the bar from i3, a barconfig-update event was introduced, for which a bar can subscribe and the bar then gets notified about the currently set hidden_state and mode in its barconfig. For convenience, an id field ("id <bar_id>") was added to the barconfig, where one can set the desired id for the corresponding bar. If the id is not specified, i3 will deterministically choose an id; otherwise, with the previous random approach for finding a new id, which is actually not shared with i3bar, as it would determine its id on startup, the event-subscription would be destroyed on reload. Still, this issue remains when manually changing the bar_id in the config and then reloading. fixes #833, #651
2013-05-25 14:30:00 +02:00
}
if (bar_id && !changed_sth) {
DLOG("Changing bar hidden_state of bar_id %s failed, bar_id not found.\n", bar_id);
return false;
}
return true;
}
/*
* Implementation of 'bar (hidden_state hide|show|toggle)|(mode dock|hide|invisible|toggle) [<bar_id>]'
*
*/
void cmd_bar(I3_CMD, char *bar_type, char *bar_value, char *bar_id) {
bool ret;
if (strcmp(bar_type, "mode") == 0)
ret = cmd_bar_mode(bar_value, bar_id);
else if (strcmp(bar_type, "hidden_state") == 0)
ret = cmd_bar_hidden_state(bar_value, bar_id);
else {
ELOG("Unknown bar option type \"%s\", this is a mismatch between code and parser spec.\n", bar_type);
ret = false;
}
ysuccess(ret);
if (!ret)
return;
update_barconfig();
}
Implement shmlog command Add shmlog command that takes <size>|toggle|on|off. Separate logbuffer management into open_logbuffer() and close_logbuffer(). Make t/187-commands-parser.t expect 'shmlog'. Add update_shmlog_atom() to update the SHMLOG_PATH. Document the shmlog command in userguide.
2013-06-05 15:04:57 +02:00
/*
* Implementation of 'shmlog <size>|toggle|on|off'
*
*/
void cmd_shmlog(I3_CMD, char *argument) {
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
if (!strcmp(argument, "toggle"))
Implement shmlog command Add shmlog command that takes <size>|toggle|on|off. Separate logbuffer management into open_logbuffer() and close_logbuffer(). Make t/187-commands-parser.t expect 'shmlog'. Add update_shmlog_atom() to update the SHMLOG_PATH. Document the shmlog command in userguide.
2013-06-05 15:04:57 +02:00
/* Toggle shm log, if size is not 0. If it is 0, set it to default. */
shmlog_size = shmlog_size ? -shmlog_size : default_shmlog_size;
else if (!strcmp(argument, "on"))
shmlog_size = default_shmlog_size;
else if (!strcmp(argument, "off"))
shmlog_size = 0;
else {
/* If shm logging now, restart logging with the new size. */
if (shmlog_size > 0) {
shmlog_size = 0;
LOG("Restarting shm logging...\n");
init_logging();
}
shmlog_size = atoi(argument);
/* Make a weakly attempt at ensuring the argument is valid. */
if (shmlog_size <= 0)
shmlog_size = default_shmlog_size;
}
LOG("%s shm logging\n", shmlog_size > 0 ? "Enabling" : "Disabling");
init_logging();
update_shmlog_atom();
// XXX: default reply for now, make this a better reply
ysuccess(true);
}
Implement debuglog command Add debuglog command that takes toggle|on|off. Add get_debug_logging() to be able to toggle. Make t/187-commands-parser.t expect 'debuglog'. Document the debuglog command in userguide.
2013-06-05 15:06:53 +02:00
/*
* Implementation of 'debuglog toggle|on|off'
*
*/
void cmd_debuglog(I3_CMD, char *argument) {
bool logging = get_debug_logging();
format **/*.c with clang-format-3.5 This has multiple effects: 1) The i3 codebase is now consistently formatted. clang-format uncovered plenty of places where inconsistent code made it into our code base. 2) When writing code, you don’t need to think or worry about our coding style. Write it in yours, then run clang-format-3.5 3) When submitting patches, we don’t need to argue about coding style. The basic idea is that we don’t want to care about _how_ we write the code, but _what_ it does :). The coding style that we use is defined in the .clang-format config file and is based on the google style, but adapted in such a way that the number of modifications to the i3 code base is minimal.
2014-06-15 19:07:02 +02:00
if (!strcmp(argument, "toggle")) {
Implement debuglog command Add debuglog command that takes toggle|on|off. Add get_debug_logging() to be able to toggle. Make t/187-commands-parser.t expect 'debuglog'. Document the debuglog command in userguide.
2013-06-05 15:06:53 +02:00
LOG("%s debug logging\n", logging ? "Disabling" : "Enabling");
set_debug_logging(!logging);
} else if (!strcmp(argument, "on") && !logging) {
LOG("Enabling debug logging\n");
set_debug_logging(true);
} else if (!strcmp(argument, "off") && logging) {
LOG("Disabling debug logging\n");
set_debug_logging(false);
}
// XXX: default reply for now, make this a better reply
ysuccess(true);
}