#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
-#include <limits.h>
+#include <float.h>
#include "all.h"
typedef struct yy_buffer_state *YY_BUFFER_STATE;
extern int cmdyylex(struct context *context);
extern int cmdyyparse(void);
+extern int cmdyylex_destroy(void);
extern FILE *cmdyyin;
YY_BUFFER_STATE cmdyy_scan_string(const char *);
}
char *parse_cmd(const char *new) {
+ json_output = NULL;
LOG("COMMAND: *%s*\n", new);
cmdyy_scan_string(new);
match_init(¤t_match);
context = scalloc(sizeof(struct context));
context->filename = "cmd";
- FREE(json_output);
if (cmdyyparse() != 0) {
fprintf(stderr, "Could not parse command\n");
asprintf(&json_output, "{\"success\":false, \"error\":\"%s at position %d\"}",
}
printf("done, json output = %s\n", json_output);
+ cmdyylex_destroy();
FREE(context->line_copy);
FREE(context->compact_error);
free(context);
return json_output;
}
+/*
+ * Returns true if a is definitely greater than b (using the given epsilon)
+ *
+ */
+bool definitelyGreaterThan(float a, float b, float epsilon) {
+ return (a - b) > ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
+}
+
%}
-%expect 5
%error-verbose
%lex-param { struct context *context }
int number;
}
-%token TOK_ATTACH "attach"
%token TOK_EXEC "exec"
%token TOK_EXIT "exit"
%token TOK_RELOAD "reload"
%token TOK_MODE "mode"
%token TOK_TILING "tiling"
%token TOK_FLOATING "floating"
+%token TOK_MODE_TOGGLE "mode_toggle"
+%token TOK_ENABLE "enable"
+%token TOK_DISABLE "disable"
%token TOK_WORKSPACE "workspace"
+%token TOK_OUTPUT "output"
%token TOK_TOGGLE "toggle"
%token TOK_FOCUS "focus"
%token TOK_MOVE "move"
%token TOK_SPLIT "split"
%token TOK_HORIZONTAL "horizontal"
%token TOK_VERTICAL "vertical"
-%token TOK_LEVEL "level"
%token TOK_UP "up"
%token TOK_DOWN "down"
%token TOK_LEFT "left"
%token TOK_RIGHT "right"
-%token TOK_RESTORE "restore"
+%token TOK_PARENT "parent"
+%token TOK_CHILD "child"
+%token TOK_APPEND_LAYOUT "append_layout"
%token TOK_MARK "mark"
%token TOK_RESIZE "resize"
%token TOK_GROW "grow"
%token TOK_NOP "nop"
%token TOK_CLASS "class"
+%token TOK_INSTANCE "instance"
+%token TOK_WINDOW_ROLE "window_role"
%token TOK_ID "id"
%token TOK_CON_ID "con_id"
+%token TOK_TITLE "title"
-%token WHITESPACE "<whitespace>"
%token <string> STR "<string>"
%token <number> NUMBER "<number>"
%type <number> direction
-%type <chr> level_direction
+%type <number> split_direction
+%type <number> fullscreen_mode
+%type <number> level
%type <number> window_mode
+%type <number> boolean
%type <number> border_style
%type <number> layout_mode
%type <number> resize_px
%%
commands:
- commands optwhitespace ';' optwhitespace command
+ commands ';' command
| command
{
owindow *current;
}
;
-optwhitespace:
- | WHITESPACE
- ;
-
command:
- match optwhitespace operations
+ match operations
;
match:
- | matchstart optwhitespace criteria optwhitespace matchend
+ | matchstart criteria matchend
{
printf("match parsed\n");
}
}
} else if (current_match.mark != NULL && current->con->mark != NULL &&
- strcasecmp(current_match.mark, current->con->mark) == 0) {
+ regex_matches(current_match.mark, current->con->mark)) {
printf("match by mark\n");
- TAILQ_INSERT_TAIL(&owindows, current, owindows);
-
+ TAILQ_INSERT_TAIL(&owindows, current, owindows);
} else {
if (current->con->window == NULL)
continue;
;
criteria:
+ criteria criterion
+ | criterion
+ ;
+
+criterion:
TOK_CLASS '=' STR
{
printf("criteria: class = %s\n", $3);
- current_match.class = $3;
+ current_match.class = regex_new($3);
+ free($3);
+ }
+ | TOK_INSTANCE '=' STR
+ {
+ printf("criteria: instance = %s\n", $3);
+ current_match.instance = regex_new($3);
+ free($3);
+ }
+ | TOK_WINDOW_ROLE '=' STR
+ {
+ printf("criteria: window_role = %s\n", $3);
+ current_match.role = regex_new($3);
+ free($3);
}
| TOK_CON_ID '=' STR
{
| TOK_MARK '=' STR
{
printf("criteria: mark = %s\n", $3);
- current_match.mark = $3;
+ current_match.mark = regex_new($3);
+ free($3);
+ }
+ | TOK_TITLE '=' STR
+ {
+ printf("criteria: title = %s\n", $3);
+ current_match.title = regex_new($3);
+ free($3);
}
;
operations:
- operation optwhitespace
- | operations ',' optwhitespace operation
+ operation
+ | operations ',' operation
;
operation:
| reload
| border
| layout
- | restore
+ | append_layout
| move
| workspace
- | attach
| focus
| kill
| open
| fullscreen
- | next
- | prev
| split
- | mode
- | level
+ | floating
| mark
| resize
| nop
+ | mode
;
exec:
- TOK_EXEC WHITESPACE STR
+ TOK_EXEC STR
{
- printf("should execute %s\n", $3);
- start_application($3);
- free($3);
+ printf("should execute %s\n", $2);
+ start_application($2);
+ free($2);
}
;
TOK_RELOAD
{
printf("reloading\n");
+ kill_configerror_nagbar(false);
load_configuration(conn, NULL, true);
x_set_i3_atoms();
/* Send an IPC event just in case the ws names have changed */
}
;
-attach:
- TOK_ATTACH
- {
- printf("should attach\n");
- }
- ;
-
focus:
TOK_FOCUS
{
owindow *current;
- printf("should focus\n");
if (match_is_empty(¤t_match)) {
- /* TODO: better error message */
- LOG("Error: The focus command requires you to use some criteria.\n");
+ ELOG("You have to specify which window/container should be focused.\n");
+ ELOG("Example: [class=\"urxvt\" title=\"irssi\"] focus\n");
+
+ asprintf(&json_output, "{\"success\":false, \"error\":\"You have to "
+ "specify which window/container should be focused\"}");
break;
}
- /* TODO: warning if the match contains more than one entry. does not
- * make so much sense when focusing */
+ int count = 0;
TAILQ_FOREACH(current, &owindows, owindows) {
+ Con *ws = con_get_workspace(current->con);
+ workspace_show(ws->name);
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, "
+ "while only exactly one container can be focused at a time.\n", count);
+
+ tree_render();
+ }
+ | TOK_FOCUS direction
+ {
+ int direction = $2;
+ switch (direction) {
+ case TOK_LEFT:
+ LOG("Focusing left\n");
+ tree_next('p', HORIZ);
+ break;
+ case TOK_RIGHT:
+ LOG("Focusing right\n");
+ tree_next('n', HORIZ);
+ break;
+ case TOK_UP:
+ LOG("Focusing up\n");
+ tree_next('p', VERT);
+ break;
+ case TOK_DOWN:
+ LOG("Focusing down\n");
+ tree_next('n', VERT);
+ break;
+ default:
+ ELOG("Invalid focus direction (%d)\n", direction);
+ break;
+ }
+
+ tree_render();
+ }
+ | TOK_FOCUS window_mode
+ {
+ printf("should focus: ");
+
+ if ($2 == TOK_TILING)
+ printf("tiling\n");
+ else if ($2 == TOK_FLOATING)
+ printf("floating\n");
+ else printf("mode toggle\n");
+
+ Con *ws = con_get_workspace(focused);
+ Con *current;
+ if (ws != NULL) {
+ int to_focus = $2;
+ if ($2 == TOK_MODE_TOGGLE) {
+ current = TAILQ_FIRST(&(ws->focus_head));
+ if (current != NULL && current->type == CT_FLOATING_CON)
+ to_focus = TOK_TILING;
+ else to_focus = TOK_FLOATING;
+ }
+ TAILQ_FOREACH(current, &(ws->focus_head), focused) {
+ if ((to_focus == TOK_FLOATING && current->type != CT_FLOATING_CON) ||
+ (to_focus == TOK_TILING && current->type == CT_FLOATING_CON))
+ continue;
+
+ con_focus(con_descend_focused(current));
+ break;
+ }
}
+
+ tree_render();
}
+ | TOK_FOCUS level
+ {
+ if ($2 == TOK_PARENT)
+ level_up();
+ else level_down();
+
+ tree_render();
+ }
+ ;
+
+window_mode:
+ TOK_TILING { $$ = TOK_TILING; }
+ | TOK_FLOATING { $$ = TOK_FLOATING; }
+ | TOK_MODE_TOGGLE { $$ = TOK_MODE_TOGGLE; }
+ ;
+
+level:
+ TOK_PARENT { $$ = TOK_PARENT; }
+ | TOK_CHILD { $$ = TOK_CHILD; }
;
kill:
}
}
+ tree_render();
}
;
optional_kill_mode:
/* empty */ { $$ = KILL_WINDOW; }
- | WHITESPACE { $$ = KILL_WINDOW; }
- | WHITESPACE TOK_WINDOW { $$ = KILL_WINDOW; }
- | WHITESPACE TOK_CLIENT { $$ = KILL_CLIENT; }
+ | TOK_WINDOW { $$ = KILL_WINDOW; }
+ | TOK_CLIENT { $$ = KILL_CLIENT; }
;
workspace:
- TOK_WORKSPACE WHITESPACE STR
+ TOK_WORKSPACE TOK_NEXT
{
- printf("should switch to workspace %s\n", $3);
- workspace_show($3);
- free($3);
+ workspace_next();
+ tree_render();
+ }
+ | TOK_WORKSPACE TOK_PREV
+ {
+ workspace_prev();
+ tree_render();
+ }
+ | TOK_WORKSPACE STR
+ {
+ printf("should switch to workspace %s\n", $2);
+ workspace_show($2);
+ free($2);
+
+ tree_render();
}
;
TOK_OPEN
{
printf("opening new container\n");
- Con *con = tree_open_con(NULL);
+ Con *con = tree_open_con(NULL, NULL);
con_focus(con);
asprintf(&json_output, "{\"success\":true, \"id\":%ld}", (long int)con);
+
+ tree_render();
}
;
fullscreen:
- TOK_FULLSCREEN
+ TOK_FULLSCREEN fullscreen_mode
{
- printf("toggling fullscreen\n");
+ printf("toggling fullscreen, mode = %s\n", ($2 == CF_OUTPUT ? "normal" : "global"));
owindow *current;
-
HANDLE_EMPTY_MATCH;
TAILQ_FOREACH(current, &owindows, owindows) {
printf("matching: %p / %s\n", current->con, current->con->name);
- con_toggle_fullscreen(current->con);
+ con_toggle_fullscreen(current->con, $2);
}
- }
- ;
-next:
- TOK_NEXT WHITESPACE direction
- {
- /* TODO: use matches */
- printf("should select next window in direction %c\n", $3);
- tree_next('n', ($3 == 'v' ? VERT : HORIZ));
+ tree_render();
}
;
-prev:
- TOK_PREV WHITESPACE direction
- {
- /* TODO: use matches */
- printf("should select prev window in direction %c\n", $3);
- tree_next('p', ($3 == 'v' ? VERT : HORIZ));
- }
+fullscreen_mode:
+ /* empty */ { $$ = CF_OUTPUT; }
+ | TOK_GLOBAL { $$ = CF_GLOBAL; }
;
split:
- TOK_SPLIT WHITESPACE direction
+ TOK_SPLIT split_direction
{
/* TODO: use matches */
- printf("splitting in direction %c\n", $3);
- tree_split(focused, ($3 == 'v' ? VERT : HORIZ));
+ printf("splitting in direction %c\n", $2);
+ tree_split(focused, ($2 == 'v' ? VERT : HORIZ));
+
+ tree_render();
}
;
-direction:
+split_direction:
TOK_HORIZONTAL { $$ = 'h'; }
| 'h' { $$ = 'h'; }
| TOK_VERTICAL { $$ = 'v'; }
| 'v' { $$ = 'v'; }
;
-mode:
- TOK_MODE WHITESPACE window_mode
+floating:
+ TOK_FLOATING boolean
{
HANDLE_EMPTY_MATCH;
owindow *current;
TAILQ_FOREACH(current, &owindows, owindows) {
printf("matching: %p / %s\n", current->con, current->con->name);
- if ($3 == TOK_TOGGLE) {
+ if ($2 == TOK_TOGGLE) {
printf("should toggle mode\n");
toggle_floating_mode(current->con, false);
} else {
- printf("should switch mode to %s\n", ($3 == TOK_FLOATING ? "floating" : "tiling"));
- if ($3 == TOK_FLOATING) {
+ printf("should switch mode to %s\n", ($2 == TOK_FLOATING ? "floating" : "tiling"));
+ if ($2 == TOK_ENABLE) {
floating_enable(current->con, false);
} else {
floating_disable(current->con, false);
}
}
}
+
+ tree_render();
}
;
-window_mode:
- TOK_FLOATING { $$ = TOK_FLOATING; }
- | TOK_TILING { $$ = TOK_TILING; }
- | TOK_TOGGLE { $$ = TOK_TOGGLE; }
+boolean:
+ TOK_ENABLE { $$ = TOK_ENABLE; }
+ | TOK_DISABLE { $$ = TOK_DISABLE; }
+ | TOK_TOGGLE { $$ = TOK_TOGGLE; }
;
border:
- TOK_BORDER WHITESPACE border_style
+ TOK_BORDER border_style
{
- printf("border style should be changed to %d\n", $3);
+ printf("border style should be changed to %d\n", $2);
owindow *current;
HANDLE_EMPTY_MATCH;
TAILQ_FOREACH(current, &owindows, owindows) {
printf("matching: %p / %s\n", current->con, current->con->name);
- current->con->border_style = $3;
+ if ($2 == TOK_TOGGLE) {
+ current->con->border_style++;
+ current->con->border_style %= 3;
+ } else current->con->border_style = $2;
}
+
+ tree_render();
}
;
TOK_NORMAL { $$ = BS_NORMAL; }
| TOK_NONE { $$ = BS_NONE; }
| TOK_1PIXEL { $$ = BS_1PIXEL; }
+ | TOK_TOGGLE { $$ = TOK_TOGGLE; }
;
-
-level:
- TOK_LEVEL WHITESPACE level_direction
+move:
+ TOK_MOVE direction
{
- printf("level %c\n", $3);
- if ($3 == 'u')
- level_up();
- else level_down();
+ printf("moving in direction %d\n", $2);
+ tree_move($2);
+
+ tree_render();
}
- ;
+ | TOK_MOVE TOK_WORKSPACE STR
+ {
+ owindow *current;
-level_direction:
- TOK_UP { $$ = 'u'; }
- | TOK_DOWN { $$ = 'd'; }
- ;
+ printf("should move window to workspace %s\n", $3);
+ /* get the workspace */
+ Con *ws = workspace_get($3, NULL);
+ free($3);
-move:
- TOK_MOVE WHITESPACE direction
- {
- printf("moving in direction %d\n", $3);
- tree_move($3);
+ HANDLE_EMPTY_MATCH;
+
+ TAILQ_FOREACH(current, &owindows, owindows) {
+ printf("matching: %p / %s\n", current->con, current->con->name);
+ con_move_to_workspace(current->con, ws, true, false);
+ }
+
+ tree_render();
}
- | TOK_MOVE WHITESPACE TOK_WORKSPACE WHITESPACE STR
+ | TOK_MOVE TOK_OUTPUT STR
{
owindow *current;
- printf("should move window to workspace %s\n", $5);
- /* get the workspace */
- Con *ws = workspace_get($5, NULL);
- free($5);
+ printf("should move window to output %s", $3);
HANDLE_EMPTY_MATCH;
+ /* get the output */
+ Output *current_output = NULL;
+ Output *output;
+
+ TAILQ_FOREACH(current, &owindows, owindows)
+ current_output = get_output_containing(current->con->rect.x, current->con->rect.y);
+
+ assert(current_output != NULL);
+
+ if (strcasecmp($3, "up") == 0)
+ output = get_output_next(D_UP, current_output);
+ else if (strcasecmp($3, "down") == 0)
+ output = get_output_next(D_DOWN, current_output);
+ else if (strcasecmp($3, "left") == 0)
+ output = get_output_next(D_LEFT, current_output);
+ else if (strcasecmp($3, "right") == 0)
+ output = get_output_next(D_RIGHT, current_output);
+ else
+ output = get_output_by_name($3);
+ free($3);
+
+ if (!output)
+ break;
+
+ /* get visible workspace on output */
+ Con *ws = NULL;
+ GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
+ if (!ws)
+ break;
+
TAILQ_FOREACH(current, &owindows, owindows) {
printf("matching: %p / %s\n", current->con, current->con->name);
- con_move_to_workspace(current->con, ws);
+ con_move_to_workspace(current->con, ws, true, false);
}
+
+ tree_render();
}
;
-restore:
- TOK_RESTORE WHITESPACE STR
+append_layout:
+ TOK_APPEND_LAYOUT STR
{
- printf("restoring \"%s\"\n", $3);
- tree_append_json($3);
- free($3);
+ printf("restoring \"%s\"\n", $2);
+ tree_append_json($2);
+ free($2);
+ tree_render();
}
;
layout:
- TOK_LAYOUT WHITESPACE layout_mode
+ TOK_LAYOUT layout_mode
{
- printf("changing layout to %d\n", $3);
+ printf("changing layout to %d\n", $2);
owindow *current;
/* check if the match is empty, not if the result is empty */
if (match_is_empty(¤t_match))
- con_set_layout(focused->parent, $3);
+ con_set_layout(focused->parent, $2);
else {
TAILQ_FOREACH(current, &owindows, owindows) {
printf("matching: %p / %s\n", current->con, current->con->name);
- con_set_layout(current->con, $3);
+ con_set_layout(current->con, $2);
}
}
+
+ tree_render();
}
;
;
mark:
- TOK_MARK WHITESPACE STR
+ TOK_MARK STR
{
- printf("marking window with str %s\n", $3);
+ printf("marking window with str %s\n", $2);
owindow *current;
HANDLE_EMPTY_MATCH;
TAILQ_FOREACH(current, &owindows, owindows) {
printf("matching: %p / %s\n", current->con, current->con->name);
- current->con->mark = sstrdup($3);
+ current->con->mark = sstrdup($2);
}
- free($<string>3);
+ free($<string>2);
+
+ tree_render();
}
;
nop:
- TOK_NOP WHITESPACE STR
+ TOK_NOP STR
{
printf("-------------------------------------------------\n");
- printf(" NOP: %s\n", $3);
+ printf(" NOP: %s\n", $2);
printf("-------------------------------------------------\n");
- free($3);
+ free($2);
}
;
resize:
- TOK_RESIZE WHITESPACE resize_way WHITESPACE direction resize_px resize_tiling
+ TOK_RESIZE resize_way direction resize_px resize_tiling
{
/* resize <grow|shrink> <direction> [<px> px] [or <ppt> ppt] */
- printf("resizing in way %d, direction %d, px %d or ppt %d\n", $3, $5, $6, $7);
- int direction = $5;
- int px = $6;
- int ppt = $7;
- if ($3 == TOK_SHRINK) {
+ printf("resizing in way %d, direction %d, px %d or ppt %d\n", $2, $3, $4, $5);
+ int direction = $3;
+ int px = $4;
+ int ppt = $5;
+ if ($2 == TOK_SHRINK) {
px *= -1;
ppt *= -1;
}
focused->parent->rect.y -= px;
focused->parent->rect.height += px;
} else if (direction == TOK_DOWN) {
- focused->rect.height += px;
+ focused->parent->rect.height += px;
} else if (direction == TOK_LEFT) {
- focused->rect.x -= px;
- focused->rect.width += px;
+ focused->parent->rect.x -= px;
+ focused->parent->rect.width += px;
} else {
- focused->rect.width += px;
+ focused->parent->rect.width += px;
}
} else {
LOG("tiling resize\n");
+ /* get the appropriate current container (skip stacked/tabbed cons) */
+ Con *current = focused;
+ while (current->parent->layout == L_STACKED ||
+ current->parent->layout == L_TABBED)
+ current = current->parent;
/* get the default percentage */
- int children = con_num_children(focused->parent);
+ int children = con_num_children(current->parent);
Con *other;
LOG("ins. %d children\n", children);
double percentage = 1.0 / children;
LOG("default percentage = %f\n", percentage);
+ orientation_t orientation = current->parent->orientation;
+
+ if ((orientation == HORIZ &&
+ (direction == TOK_UP || direction == TOK_DOWN)) ||
+ (orientation == VERT &&
+ (direction == TOK_LEFT || direction == TOK_RIGHT))) {
+ LOG("You cannot resize in that direction. Your focus is in a %s split container currently.\n",
+ (orientation == HORIZ ? "horizontal" : "vertical"));
+ break;
+ }
+
if (direction == TOK_UP || direction == TOK_LEFT) {
- other = TAILQ_PREV(focused, nodes_head, nodes);
+ other = TAILQ_PREV(current, nodes_head, nodes);
} else {
- other = TAILQ_NEXT(focused, nodes);
+ other = TAILQ_NEXT(current, nodes);
}
if (other == TAILQ_END(workspaces)) {
LOG("No other container in this direction found, cannot resize.\n");
- return 0;
+ break;
}
LOG("other->percent = %f\n", other->percent);
- LOG("focused->percent before = %f\n", focused->percent);
- if (focused->percent == 0.0)
- focused->percent = percentage;
+ LOG("current->percent before = %f\n", current->percent);
+ if (current->percent == 0.0)
+ current->percent = percentage;
if (other->percent == 0.0)
other->percent = percentage;
- focused->percent += ((double)ppt / 100.0);
- other->percent -= ((double)ppt / 100.0);
- LOG("focused->percent after = %f\n", focused->percent);
- LOG("other->percent after = %f\n", other->percent);
+ double new_current_percent = current->percent + ((double)ppt / 100.0);
+ double new_other_percent = other->percent - ((double)ppt / 100.0);
+ LOG("new_current_percent = %f\n", new_current_percent);
+ LOG("new_other_percent = %f\n", new_other_percent);
+ /* Ensure that the new percentages are positive and greater than
+ * 0.05 to have a reasonable minimum size. */
+ if (definitelyGreaterThan(new_current_percent, 0.05, DBL_EPSILON) &&
+ definitelyGreaterThan(new_other_percent, 0.05, DBL_EPSILON)) {
+ current->percent += ((double)ppt / 100.0);
+ other->percent -= ((double)ppt / 100.0);
+ LOG("current->percent after = %f\n", current->percent);
+ LOG("other->percent after = %f\n", other->percent);
+ } else {
+ LOG("Not resizing, already at minimum size\n");
+ }
}
+
+ tree_render();
}
;
{
$$ = 10;
}
- | WHITESPACE NUMBER WHITESPACE TOK_PX
+ | NUMBER TOK_PX
{
- $$ = $2;
+ $$ = $1;
}
;
{
$$ = 10;
}
- | WHITESPACE TOK_OR WHITESPACE NUMBER WHITESPACE TOK_PPT
+ | TOK_OR NUMBER TOK_PPT
{
- $$ = $4;
+ $$ = $2;
}
;
| TOK_LEFT { $$ = TOK_LEFT; }
| TOK_RIGHT { $$ = TOK_RIGHT; }
;
+
+mode:
+ TOK_MODE STR
+ {
+ switch_mode($2);
+ }
+ ;
projects / i3 / i3 / blobdiff