2015-08-05 01:30:40 +00:00
|
|
|
#include <stdio.h>
|
2015-08-05 21:30:40 +00:00
|
|
|
#include <stdbool.h>
|
2015-08-05 01:30:40 +00:00
|
|
|
#include <stdlib.h>
|
2015-08-16 00:51:23 +00:00
|
|
|
#include <unistd.h>
|
2015-11-28 15:00:53 +00:00
|
|
|
#include <wordexp.h>
|
2015-08-05 01:30:40 +00:00
|
|
|
#include "readline.h"
|
|
|
|
#include "stringop.h"
|
|
|
|
#include "list.h"
|
2015-08-08 23:24:18 +00:00
|
|
|
#include "log.h"
|
2015-08-05 21:30:40 +00:00
|
|
|
#include "commands.h"
|
2015-08-05 01:30:40 +00:00
|
|
|
#include "config.h"
|
2015-08-19 02:05:58 +00:00
|
|
|
#include "layout.h"
|
2015-08-20 21:14:26 +00:00
|
|
|
#include "input_state.h"
|
2015-11-17 18:27:01 +00:00
|
|
|
#include "criteria.h"
|
2015-08-05 01:30:40 +00:00
|
|
|
|
2015-09-07 06:22:02 +00:00
|
|
|
struct sway_config *config = NULL;
|
2015-08-11 00:50:22 +00:00
|
|
|
|
2015-09-07 13:52:27 +00:00
|
|
|
static void free_variable(struct sway_variable *var) {
|
|
|
|
free(var->name);
|
|
|
|
free(var->value);
|
|
|
|
free(var);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_binding(struct sway_binding *bind) {
|
|
|
|
free_flat_list(bind->keys);
|
|
|
|
free(bind->command);
|
|
|
|
free(bind);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_mode(struct sway_mode *mode) {
|
|
|
|
free(mode->name);
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < mode->bindings->length; ++i) {
|
|
|
|
free_binding(mode->bindings->items[i]);
|
|
|
|
}
|
|
|
|
list_free(mode->bindings);
|
|
|
|
free(mode);
|
|
|
|
}
|
|
|
|
|
2015-11-16 10:40:24 +00:00
|
|
|
void free_output_config(struct output_config *oc) {
|
2015-09-07 13:52:27 +00:00
|
|
|
free(oc->name);
|
|
|
|
free(oc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_workspace_output(struct workspace_output *wo) {
|
|
|
|
free(wo->output);
|
|
|
|
free(wo->workspace);
|
|
|
|
free(wo);
|
|
|
|
}
|
|
|
|
|
2015-09-07 21:29:40 +00:00
|
|
|
static void free_config(struct sway_config *config) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < config->symbols->length; ++i) {
|
|
|
|
free_variable(config->symbols->items[i]);
|
|
|
|
}
|
|
|
|
list_free(config->symbols);
|
|
|
|
|
|
|
|
for (i = 0; i < config->modes->length; ++i) {
|
|
|
|
free_mode(config->modes->items[i]);
|
|
|
|
}
|
|
|
|
list_free(config->modes);
|
|
|
|
|
|
|
|
free_flat_list(config->cmd_queue);
|
|
|
|
|
|
|
|
for (i = 0; i < config->workspace_outputs->length; ++i) {
|
|
|
|
free_workspace_output(config->workspace_outputs->items[i]);
|
|
|
|
}
|
|
|
|
list_free(config->workspace_outputs);
|
|
|
|
|
2015-11-17 18:27:01 +00:00
|
|
|
for (i = 0; i < config->criteria->length; ++i) {
|
|
|
|
free_criteria(config->criteria->items[i]);
|
|
|
|
}
|
|
|
|
list_free(config->criteria);
|
|
|
|
|
2015-09-07 21:29:40 +00:00
|
|
|
for (i = 0; i < config->output_configs->length; ++i) {
|
2015-09-08 12:37:20 +00:00
|
|
|
free_output_config(config->output_configs->items[i]);
|
2015-09-07 21:29:40 +00:00
|
|
|
}
|
|
|
|
list_free(config->output_configs);
|
|
|
|
free(config);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-09-07 05:48:43 +00:00
|
|
|
static bool file_exists(const char *path) {
|
2015-08-16 00:51:23 +00:00
|
|
|
return access(path, R_OK) != -1;
|
|
|
|
}
|
|
|
|
|
2015-09-07 05:48:43 +00:00
|
|
|
static void config_defaults(struct sway_config *config) {
|
2015-08-19 11:50:27 +00:00
|
|
|
config->symbols = create_list();
|
|
|
|
config->modes = create_list();
|
|
|
|
config->workspace_outputs = create_list();
|
2015-11-17 18:27:01 +00:00
|
|
|
config->criteria = create_list();
|
2015-08-22 15:18:55 +00:00
|
|
|
config->output_configs = create_list();
|
2015-09-07 05:48:43 +00:00
|
|
|
|
|
|
|
config->cmd_queue = create_list();
|
|
|
|
|
2015-08-19 11:50:27 +00:00
|
|
|
config->current_mode = malloc(sizeof(struct sway_mode));
|
2015-09-07 21:29:40 +00:00
|
|
|
config->current_mode->name = malloc(sizeof("default"));
|
|
|
|
strcpy(config->current_mode->name, "default");
|
2015-08-19 11:50:27 +00:00
|
|
|
config->current_mode->bindings = create_list();
|
|
|
|
list_add(config->modes, config->current_mode);
|
2015-09-07 05:48:43 +00:00
|
|
|
|
2015-08-28 21:45:40 +00:00
|
|
|
config->floating_mod = 0;
|
2015-08-28 02:52:59 +00:00
|
|
|
config->default_layout = L_NONE;
|
|
|
|
config->default_orientation = L_NONE;
|
2015-08-19 11:50:27 +00:00
|
|
|
// Flags
|
|
|
|
config->focus_follows_mouse = true;
|
|
|
|
config->mouse_warping = true;
|
|
|
|
config->reloading = false;
|
|
|
|
config->active = false;
|
|
|
|
config->failed = false;
|
2015-08-31 02:34:10 +00:00
|
|
|
config->auto_back_and_forth = false;
|
2015-10-21 23:34:32 +00:00
|
|
|
config->seamless_mouse = true;
|
2015-09-10 18:07:40 +00:00
|
|
|
config->reading = false;
|
2015-08-28 21:45:40 +00:00
|
|
|
|
2015-11-12 13:02:39 +00:00
|
|
|
config->edge_gaps = true;
|
2015-08-19 11:50:27 +00:00
|
|
|
config->gaps_inner = 0;
|
|
|
|
config->gaps_outer = 0;
|
|
|
|
}
|
2015-08-16 00:51:23 +00:00
|
|
|
|
2015-09-07 05:48:43 +00:00
|
|
|
static char *get_config_path(void) {
|
2015-11-28 15:00:53 +00:00
|
|
|
static const char *config_paths[] = {
|
|
|
|
"$HOME/.sway/config",
|
|
|
|
"$XDG_CONFIG_HOME/sway/config",
|
|
|
|
"$HOME/.i3/config",
|
|
|
|
"$XDG_CONFIG_HOME/i3/config",
|
2015-11-13 13:17:29 +00:00
|
|
|
"/etc/sway/config",
|
2015-11-28 15:00:53 +00:00
|
|
|
"/etc/i3/config",
|
2015-09-07 05:48:43 +00:00
|
|
|
};
|
2015-11-28 15:00:53 +00:00
|
|
|
|
|
|
|
if (!getenv("XDG_CONFIG_HOME")) {
|
|
|
|
char *home = getenv("HOME");
|
|
|
|
char *config_home = malloc(strlen("home") + strlen("/.config") + 1);
|
|
|
|
strcpy(config_home, home);
|
|
|
|
strcat(config_home, "/.config");
|
|
|
|
setenv("XDG_CONFIG_HOME", config_home, 1);
|
|
|
|
sway_log(L_DEBUG, "Set XDG_CONFIG_HOME to %s", config_home);
|
2015-08-16 01:03:33 +00:00
|
|
|
}
|
|
|
|
|
2015-11-28 15:00:53 +00:00
|
|
|
wordexp_t p;
|
|
|
|
char *path;
|
|
|
|
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < (int)(sizeof(config_paths) / sizeof(char *)); ++i) {
|
|
|
|
if (wordexp(config_paths[i], &p, 0) == 0) {
|
|
|
|
path = p.we_wordv[0];
|
|
|
|
if (file_exists(path)) {
|
|
|
|
return path;
|
2015-08-16 01:03:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-28 15:00:53 +00:00
|
|
|
return NULL; // Not reached
|
2015-08-16 00:51:23 +00:00
|
|
|
}
|
|
|
|
|
2015-08-20 12:37:09 +00:00
|
|
|
bool load_config(const char *file) {
|
2015-08-20 21:14:26 +00:00
|
|
|
input_init();
|
|
|
|
|
2015-08-20 12:37:09 +00:00
|
|
|
char *path;
|
|
|
|
if (file != NULL) {
|
|
|
|
path = strdup(file);
|
|
|
|
} else {
|
|
|
|
path = get_config_path();
|
|
|
|
}
|
2015-08-16 00:51:23 +00:00
|
|
|
|
2015-11-28 15:00:53 +00:00
|
|
|
sway_log(L_INFO, "Loading config from %s", path);
|
|
|
|
|
2015-08-16 00:51:23 +00:00
|
|
|
if (path == NULL) {
|
|
|
|
sway_log(L_ERROR, "Unable to find a config file!");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
FILE *f = fopen(path, "r");
|
2015-08-10 19:22:22 +00:00
|
|
|
if (!f) {
|
2015-08-16 00:51:23 +00:00
|
|
|
fprintf(stderr, "Unable to open %s for reading", path);
|
|
|
|
free(path);
|
2015-08-10 19:22:22 +00:00
|
|
|
return false;
|
|
|
|
}
|
2015-08-16 00:51:23 +00:00
|
|
|
free(path);
|
2015-08-13 19:41:29 +00:00
|
|
|
|
|
|
|
bool config_load_success;
|
|
|
|
if (config) {
|
|
|
|
config_load_success = read_config(f, true);
|
|
|
|
} else {
|
|
|
|
config_load_success = read_config(f, false);
|
|
|
|
}
|
2015-08-10 19:22:22 +00:00
|
|
|
fclose(f);
|
2015-08-13 19:41:29 +00:00
|
|
|
|
|
|
|
return config_load_success;
|
2015-08-10 19:22:22 +00:00
|
|
|
}
|
|
|
|
|
2015-08-13 19:41:29 +00:00
|
|
|
bool read_config(FILE *file, bool is_active) {
|
2015-09-07 21:29:40 +00:00
|
|
|
struct sway_config *old_config = config;
|
|
|
|
config = malloc(sizeof(struct sway_config));
|
|
|
|
|
|
|
|
config_defaults(config);
|
2015-09-10 18:07:40 +00:00
|
|
|
config->reading = true;
|
2015-08-10 19:09:51 +00:00
|
|
|
if (is_active) {
|
2015-08-13 19:41:29 +00:00
|
|
|
sway_log(L_DEBUG, "Performing configuration file reload");
|
2015-09-07 21:29:40 +00:00
|
|
|
config->reloading = true;
|
|
|
|
config->active = true;
|
2015-08-10 19:09:51 +00:00
|
|
|
}
|
2015-08-06 02:10:56 +00:00
|
|
|
bool success = true;
|
2015-09-15 02:59:25 +00:00
|
|
|
enum cmd_status block = CMD_BLOCK_END;
|
2015-08-06 02:10:56 +00:00
|
|
|
|
2015-11-25 13:45:50 +00:00
|
|
|
int line_number = 0;
|
2015-09-07 21:29:40 +00:00
|
|
|
char *line;
|
2015-08-05 01:30:40 +00:00
|
|
|
while (!feof(file)) {
|
2015-09-07 21:29:40 +00:00
|
|
|
line = read_line(file);
|
2015-11-25 13:45:50 +00:00
|
|
|
line_number++;
|
2015-08-18 22:03:38 +00:00
|
|
|
line = strip_comments(line);
|
2015-10-22 12:14:13 +00:00
|
|
|
struct cmd_results *res = config_command(line);
|
|
|
|
switch(res->status) {
|
2015-09-15 02:59:25 +00:00
|
|
|
case CMD_FAILURE:
|
|
|
|
case CMD_INVALID:
|
2015-11-25 13:45:50 +00:00
|
|
|
sway_log(L_ERROR, "Error on line %i '%s': %s", line_number, line,
|
|
|
|
res->error);
|
2015-09-08 17:27:09 +00:00
|
|
|
success = false;
|
2015-09-15 02:59:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CMD_DEFER:
|
|
|
|
sway_log(L_DEBUG, "Defferring command `%s'", line);
|
|
|
|
list_add(config->cmd_queue, strdup(line));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CMD_BLOCK_MODE:
|
|
|
|
if (block == CMD_BLOCK_END) {
|
|
|
|
block = CMD_BLOCK_MODE;
|
|
|
|
} else {
|
|
|
|
sway_log(L_ERROR, "Invalid block '%s'", line);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CMD_BLOCK_END:
|
|
|
|
switch(block) {
|
|
|
|
case CMD_BLOCK_MODE:
|
|
|
|
sway_log(L_DEBUG, "End of mode block");
|
|
|
|
config->current_mode = config->modes->items[0];
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CMD_BLOCK_END:
|
|
|
|
sway_log(L_ERROR, "Unmatched }");
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:;
|
|
|
|
}
|
|
|
|
default:;
|
2015-08-16 00:51:23 +00:00
|
|
|
}
|
2015-08-05 01:30:40 +00:00
|
|
|
free(line);
|
2015-10-22 12:14:13 +00:00
|
|
|
free(res);
|
2015-08-05 01:30:40 +00:00
|
|
|
}
|
|
|
|
|
2015-08-10 19:09:51 +00:00
|
|
|
if (is_active) {
|
2015-09-07 21:29:40 +00:00
|
|
|
config->reloading = false;
|
2015-08-19 02:05:58 +00:00
|
|
|
arrange_windows(&root_container, -1, -1);
|
2015-08-10 19:09:51 +00:00
|
|
|
}
|
2015-09-07 21:29:40 +00:00
|
|
|
if (old_config) {
|
|
|
|
free_config(old_config);
|
2015-09-07 06:22:02 +00:00
|
|
|
}
|
2015-08-10 18:53:43 +00:00
|
|
|
|
2015-09-10 18:07:40 +00:00
|
|
|
config->reading = false;
|
2015-08-13 19:41:29 +00:00
|
|
|
return success;
|
2015-08-05 01:30:40 +00:00
|
|
|
}
|
2015-08-06 02:40:38 +00:00
|
|
|
|
2015-10-21 14:34:12 +00:00
|
|
|
void apply_output_config(struct output_config *oc, swayc_t *output) {
|
2015-10-21 21:59:01 +00:00
|
|
|
if (oc && oc->width > 0 && oc->height > 0) {
|
2015-10-21 14:34:12 +00:00
|
|
|
output->width = oc->width;
|
|
|
|
output->height = oc->height;
|
|
|
|
|
|
|
|
sway_log(L_DEBUG, "Set %s size to %ix%i", oc->name, oc->width, oc->height);
|
|
|
|
struct wlc_size new_size = { .w = oc->width, .h = oc->height };
|
|
|
|
wlc_output_set_resolution(output->handle, &new_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find position for it
|
|
|
|
if (oc && oc->x != -1 && oc->y != -1) {
|
|
|
|
sway_log(L_DEBUG, "Set %s position to %d, %d", oc->name, oc->x, oc->y);
|
|
|
|
output->x = oc->x;
|
|
|
|
output->y = oc->y;
|
|
|
|
} else {
|
|
|
|
int x = 0;
|
|
|
|
for (int i = 0; i < root_container.children->length; ++i) {
|
|
|
|
swayc_t *c = root_container.children->items[i];
|
|
|
|
if (c->type == C_OUTPUT) {
|
|
|
|
if (c->width + c->x > x) {
|
|
|
|
x = c->width + c->x;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
output->x = x;
|
|
|
|
}
|
2015-11-19 23:55:17 +00:00
|
|
|
|
2015-11-20 01:04:03 +00:00
|
|
|
if (oc && oc->background) {
|
2015-11-19 23:55:17 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < root_container.children->length; ++i) {
|
|
|
|
if (root_container.children->items[i] == output) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sway_log(L_DEBUG, "Setting background for output %d to %s", i, oc->background);
|
2015-11-25 21:19:08 +00:00
|
|
|
|
|
|
|
size_t bufsize = 4;
|
|
|
|
char output_id[bufsize];
|
|
|
|
snprintf(output_id, bufsize, "%d", i);
|
|
|
|
output_id[bufsize-1] = 0;
|
|
|
|
|
|
|
|
char *const cmd[] = {
|
|
|
|
"swaybg",
|
|
|
|
output_id,
|
|
|
|
oc->background,
|
|
|
|
oc->background_option,
|
|
|
|
NULL,
|
|
|
|
};
|
2015-11-19 23:55:17 +00:00
|
|
|
if (fork() == 0) {
|
2015-11-25 21:19:08 +00:00
|
|
|
execvp(cmd[0], cmd);
|
2015-11-19 23:55:17 +00:00
|
|
|
}
|
|
|
|
}
|
2015-10-21 14:34:12 +00:00
|
|
|
}
|
|
|
|
|
2015-09-07 21:29:40 +00:00
|
|
|
char *do_var_replacement(char *str) {
|
2015-08-06 02:40:38 +00:00
|
|
|
int i;
|
2015-09-08 15:54:57 +00:00
|
|
|
char *find = str;
|
|
|
|
while ((find = strchr(find, '$'))) {
|
|
|
|
// Skip if escaped.
|
2015-09-08 16:10:36 +00:00
|
|
|
if (find > str && find[-1] == '\\') {
|
|
|
|
if (find == str + 1 || !(find > str + 1 && find[-2] == '\\')) {
|
|
|
|
++find;
|
2015-09-08 15:54:57 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Find matching variable
|
|
|
|
for (i = 0; i < config->symbols->length; ++i) {
|
|
|
|
struct sway_variable *var = config->symbols->items[i];
|
|
|
|
int vnlen = strlen(var->name);
|
|
|
|
if (strncmp(find, var->name, vnlen) == 0) {
|
|
|
|
int vvlen = strlen(var->value);
|
|
|
|
char *newstr = malloc(strlen(str) - vnlen + vvlen + 1);
|
|
|
|
char *newptr = newstr;
|
|
|
|
int offset = find - str;
|
|
|
|
strncpy(newptr, str, offset);
|
|
|
|
newptr += offset;
|
|
|
|
strncpy(newptr, var->value, vvlen);
|
|
|
|
newptr += vvlen;
|
|
|
|
strcpy(newptr, find + vnlen);
|
|
|
|
free(str);
|
|
|
|
str = newstr;
|
|
|
|
find = str + offset + vvlen;
|
|
|
|
break;
|
2015-08-06 02:40:38 +00:00
|
|
|
}
|
|
|
|
}
|
2015-09-08 16:52:33 +00:00
|
|
|
if (i == config->symbols->length) {
|
|
|
|
++find;
|
|
|
|
}
|
2015-08-06 02:40:38 +00:00
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
2015-11-19 12:05:59 +00:00
|
|
|
|
|
|
|
// the naming is intentional (albeit long): a workspace_output_cmp function
|
|
|
|
// would compare two structs in full, while this method only compares the
|
|
|
|
// workspace.
|
|
|
|
int workspace_output_cmp_workspace(const void *a, const void *b) {
|
|
|
|
const struct workspace_output *wsa = a, *wsb = b;
|
|
|
|
return lenient_strcmp(wsa->workspace, wsb->workspace);
|
|
|
|
}
|
2015-11-19 15:37:48 +00:00
|
|
|
|
|
|
|
int sway_binding_cmp_keys(const void *a, const void *b) {
|
|
|
|
const struct sway_binding *binda = a, *bindb = b;
|
|
|
|
|
2015-11-24 08:30:02 +00:00
|
|
|
// Count keys pressed for this binding. important so we check long before
|
|
|
|
// short ones. for example mod+a+b before mod+a
|
|
|
|
unsigned int moda = 0, modb = 0, i;
|
|
|
|
|
|
|
|
// Count how any modifiers are pressed
|
|
|
|
for (i = 0; i < 8 * sizeof(binda->modifiers); ++i) {
|
|
|
|
moda += (binda->modifiers & 1 << i) != 0;
|
|
|
|
modb += (bindb->modifiers & 1 << i) != 0;
|
2015-11-19 15:37:48 +00:00
|
|
|
}
|
2015-11-24 08:30:02 +00:00
|
|
|
if (bindb->keys->length + modb != binda->keys->length + moda) {
|
|
|
|
return (bindb->keys->length + modb) - (binda->keys->length + moda);
|
2015-11-19 15:37:48 +00:00
|
|
|
}
|
|
|
|
|
2015-11-24 08:30:02 +00:00
|
|
|
// Otherwise compare keys
|
2015-11-24 18:15:10 +00:00
|
|
|
if (binda->modifiers > bindb->modifiers) {
|
|
|
|
return 1;
|
|
|
|
} else if (binda->modifiers < bindb->modifiers) {
|
|
|
|
return -1;
|
|
|
|
}
|
2015-11-19 15:37:48 +00:00
|
|
|
for (int i = 0; i < binda->keys->length; i++) {
|
|
|
|
xkb_keysym_t *ka = binda->keys->items[i],
|
|
|
|
*kb = bindb->keys->items[i];
|
|
|
|
if (*ka > *kb) {
|
|
|
|
return 1;
|
|
|
|
} else if (*ka < *kb) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int sway_binding_cmp(const void *a, const void *b) {
|
|
|
|
int cmp = 0;
|
|
|
|
if ((cmp = sway_binding_cmp_keys(a, b)) != 0) {
|
|
|
|
return cmp;
|
|
|
|
}
|
|
|
|
const struct sway_binding *binda = a, *bindb = b;
|
|
|
|
return lenient_strcmp(binda->command, bindb->command);
|
|
|
|
}
|
|
|
|
|
|
|
|
void free_sway_binding(struct sway_binding *binding) {
|
|
|
|
if (binding->keys) {
|
|
|
|
for (int i = 0; i < binding->keys->length; i++) {
|
|
|
|
free(binding->keys->items[i]);
|
|
|
|
}
|
|
|
|
list_free(binding->keys);
|
|
|
|
}
|
|
|
|
if (binding->command) {
|
|
|
|
free(binding->command);
|
|
|
|
}
|
|
|
|
free(binding);
|
|
|
|
}
|