Merge branch 'wlroots'

4 files changed, 718 insertions, 0 deletions

diff --git a/sway/config/bar.c b/sway/config/bar.c
new file mode 100644
index 00000000..2913f059
--- /dev/null
+++ b/sway/config/bar.c
@@ -0,0 +1,240 @@
+#define _POSIX_C_SOURCE 200809L
+#define _XOPEN_SOURCE 700
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <wordexp.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <strings.h>
+#include "sway/config.h"
+#include "stringop.h"
+#include "list.h"
+#include "log.h"
+
+static void terminate_swaybar(pid_t pid) {
+	wlr_log(L_DEBUG, "Terminating swaybar %d", pid);
+	int ret = kill(pid, SIGTERM);
+	if (ret != 0) {
+		wlr_log_errno(L_ERROR, "Unable to terminate swaybar %d", pid);
+	} else {
+		int status;
+		waitpid(pid, &status, 0);
+	}
+}
+
+void free_bar_config(struct bar_config *bar) {
+	if (!bar) {
+		return;
+	}
+	free(bar->mode);
+	free(bar->position);
+	free(bar->hidden_state);
+	free(bar->status_command);
+	free(bar->font);
+	free(bar->separator_symbol);
+	// TODO: Free mouse bindings
+	list_free(bar->bindings);
+	if (bar->outputs) {
+		free_flat_list(bar->outputs);
+	}
+	if (bar->pid != 0) {
+		terminate_swaybar(bar->pid);
+	}
+	free(bar->colors.background);
+	free(bar->colors.statusline);
+	free(bar->colors.separator);
+	free(bar->colors.focused_background);
+	free(bar->colors.focused_statusline);
+	free(bar->colors.focused_separator);
+	free(bar->colors.focused_workspace_border);
+	free(bar->colors.focused_workspace_bg);
+	free(bar->colors.focused_workspace_text);
+	free(bar->colors.active_workspace_border);
+	free(bar->colors.active_workspace_bg);
+	free(bar->colors.active_workspace_text);
+	free(bar->colors.inactive_workspace_border);
+	free(bar->colors.inactive_workspace_bg);
+	free(bar->colors.inactive_workspace_text);
+	free(bar->colors.urgent_workspace_border);
+	free(bar->colors.urgent_workspace_bg);
+	free(bar->colors.urgent_workspace_text);
+	free(bar->colors.binding_mode_border);
+	free(bar->colors.binding_mode_bg);
+	free(bar->colors.binding_mode_text);
+	free(bar);
+}
+
+struct bar_config *default_bar_config(void) {
+	struct bar_config *bar = NULL;
+	bar = malloc(sizeof(struct bar_config));
+	if (!bar) {
+		return NULL;
+	}
+	if (!(bar->mode = strdup("dock"))) goto cleanup;
+	if (!(bar->hidden_state = strdup("hide"))) goto cleanup;
+	bar->outputs = NULL;
+	bar->position = strdup("bottom");
+	if (!(bar->bindings = create_list())) goto cleanup;
+	if (!(bar->status_command = strdup("while :; do date +'%Y-%m-%d %l:%M:%S %p'; sleep 1; done"))) goto cleanup;
+	bar->pango_markup = false;
+	bar->swaybar_command = NULL;
+	bar->font = NULL;
+	bar->height = -1;
+	bar->workspace_buttons = true;
+	bar->wrap_scroll = false;
+	bar->separator_symbol = NULL;
+	bar->strip_workspace_numbers = false;
+	bar->binding_mode_indicator = true;
+	bar->verbose = false;
+	bar->pid = 0;
+	// set default colors
+	if (!(bar->colors.background = strndup("#000000ff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.statusline = strndup("#ffffffff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.separator = strndup("#666666ff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.focused_workspace_border = strndup("#4c7899ff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.focused_workspace_bg = strndup("#285577ff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.focused_workspace_text = strndup("#ffffffff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.active_workspace_border = strndup("#333333ff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.active_workspace_bg = strndup("#5f676aff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.active_workspace_text = strndup("#ffffffff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.inactive_workspace_border = strndup("#333333ff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.inactive_workspace_bg = strndup("#222222ff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.inactive_workspace_text = strndup("#888888ff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.urgent_workspace_border = strndup("#2f343aff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.urgent_workspace_bg = strndup("#900000ff", 9))) {
+		goto cleanup;
+	}
+	if (!(bar->colors.urgent_workspace_text = strndup("#ffffffff", 9))) {
+		goto cleanup;
+	}
+	// if the following colors stay undefined, they fall back to background,
+	// statusline, separator and urgent_workspace_*.
+	bar->colors.focused_background = NULL;
+	bar->colors.focused_statusline = NULL;
+	bar->colors.focused_separator = NULL;
+	bar->colors.binding_mode_border = NULL;
+	bar->colors.binding_mode_bg = NULL;
+	bar->colors.binding_mode_text = NULL;
+
+	list_add(config->bars, bar);
+	return bar;
+cleanup:
+	free_bar_config(bar);
+	return NULL;
+}
+
+void invoke_swaybar(struct bar_config *bar) {
+	// Pipe to communicate errors
+	int filedes[2];
+	if (pipe(filedes) == -1) {
+		wlr_log(L_ERROR, "Pipe setup failed! Cannot fork into bar");
+		return;
+	}
+
+	bar->pid = fork();
+	if (bar->pid == 0) {
+		close(filedes[0]);
+
+		// run custom swaybar
+		size_t len = snprintf(NULL, 0, "%s -b %s",
+				bar->swaybar_command ? bar->swaybar_command : "swaybar",
+				bar->id);
+		char *command = malloc(len + 1);
+		if (!command) {
+			const char msg[] = "Unable to allocate swaybar command string";
+			size_t len = sizeof(msg);
+			if (write(filedes[1], &len, sizeof(int))) {};
+			if (write(filedes[1], msg, len)) {};
+			close(filedes[1]);
+			exit(1);
+		}
+		snprintf(command, len + 1, "%s -b %s",
+				bar->swaybar_command ? bar->swaybar_command : "swaybar",
+				bar->id);
+		char *const cmd[] = { "sh", "-c", command, NULL, };
+		close(filedes[1]);
+		execvp(cmd[0], cmd);
+		exit(1);
+	}
+	wlr_log(L_DEBUG, "Spawned swaybar %d", bar->pid);
+	close(filedes[0]);
+	ssize_t len;
+	if (read(filedes[1], &len, sizeof(int)) == sizeof(int)) {
+		char *buf = malloc(len);
+		if(!buf) {
+			wlr_log(L_ERROR, "Cannot allocate error string");
+			return;
+		}
+		if (read(filedes[1], buf, len)) {
+			wlr_log(L_ERROR, "%s", buf);
+		}
+		free(buf);
+	}
+	close(filedes[1]);
+}
+
+static bool active_output(const char *name) {
+	struct sway_container *cont = NULL;
+	for (int i = 0; i < root_container.children->length; ++i) {
+		cont = root_container.children->items[i];
+		if (cont->type == C_OUTPUT && strcasecmp(name, cont->name) == 0) {
+			return true;
+		}
+	}
+	return false;
+}
+
+void load_swaybars() {
+	for (int i = 0; i < config->bars->length; ++i) {
+		struct bar_config *bar = config->bars->items[i];
+		bool apply = false;
+		if (bar->outputs) {
+			for (int j = 0; j < bar->outputs->length; ++j) {
+				char *o = bar->outputs->items[j];
+				if (!strcmp(o, "*") || active_output(o)) {
+					apply = true;
+					break;
+				}
+			}
+		} else {
+			apply = true;
+		}
+		if (apply) {
+			if (bar->pid != 0) {
+				terminate_swaybar(bar->pid);
+			}
+			wlr_log(L_DEBUG, "Invoking swaybar for bar id '%s'", bar->id);
+			invoke_swaybar(bar);
+		}
+	}
+}
diff --git a/sway/config/input.c b/sway/config/input.c
new file mode 100644
index 00000000..5e657c43
--- /dev/null
+++ b/sway/config/input.c
@@ -0,0 +1,119 @@
+#define _XOPEN_SOURCE 700
+#include <stdlib.h>
+#include <limits.h>
+#include <float.h>
+#include "sway/config.h"
+#include "log.h"
+
+struct input_config *new_input_config(const char* identifier) {
+	struct input_config *input = calloc(1, sizeof(struct input_config));
+	if (!input) {
+		wlr_log(L_DEBUG, "Unable to allocate input config");
+		return NULL;
+	}
+	wlr_log(L_DEBUG, "new_input_config(%s)", identifier);
+	if (!(input->identifier = strdup(identifier))) {
+		free(input);
+		wlr_log(L_DEBUG, "Unable to allocate input config");
+		return NULL;
+	}
+
+	input->tap = INT_MIN;
+	input->drag_lock = INT_MIN;
+	input->dwt = INT_MIN;
+	input->send_events = INT_MIN;
+	input->click_method = INT_MIN;
+	input->middle_emulation = INT_MIN;
+	input->natural_scroll = INT_MIN;
+	input->accel_profile = INT_MIN;
+	input->pointer_accel = FLT_MIN;
+	input->scroll_method = INT_MIN;
+	input->left_handed = INT_MIN;
+
+	return input;
+}
+
+void merge_input_config(struct input_config *dst, struct input_config *src) {
+	if (src->identifier) {
+		free(dst->identifier);
+		dst->identifier = strdup(src->identifier);
+	}
+	if (src->accel_profile != INT_MIN) {
+		dst->accel_profile = src->accel_profile;
+	}
+	if (src->click_method != INT_MIN) {
+		dst->click_method = src->click_method;
+	}
+	if (src->drag_lock != INT_MIN) {
+		dst->drag_lock = src->drag_lock;
+	}
+	if (src->dwt != INT_MIN) {
+		dst->dwt = src->dwt;
+	}
+	if (src->middle_emulation != INT_MIN) {
+		dst->middle_emulation = src->middle_emulation;
+	}
+	if (src->natural_scroll != INT_MIN) {
+		dst->natural_scroll = src->natural_scroll;
+	}
+	if (src->pointer_accel != FLT_MIN) {
+		dst->pointer_accel = src->pointer_accel;
+	}
+	if (src->scroll_method != INT_MIN) {
+		dst->scroll_method = src->scroll_method;
+	}
+	if (src->send_events != INT_MIN) {
+		dst->send_events = src->send_events;
+	}
+	if (src->tap != INT_MIN) {
+		dst->tap = src->tap;
+	}
+	if (src->xkb_layout) {
+		free(dst->xkb_layout);
+		dst->xkb_layout = strdup(src->xkb_layout);
+	}
+	if (src->xkb_model) {
+		free(dst->xkb_model);
+		dst->xkb_model = strdup(src->xkb_model);
+	}
+	if (src->xkb_options) {
+		free(dst->xkb_options);
+		dst->xkb_options = strdup(src->xkb_options);
+	}
+	if (src->xkb_rules) {
+		free(dst->xkb_rules);
+		dst->xkb_rules = strdup(src->xkb_rules);
+	}
+	if (src->xkb_variant) {
+		free(dst->xkb_variant);
+		dst->xkb_variant = strdup(src->xkb_variant);
+	}
+	if (src->mapped_output) {
+		free(dst->mapped_output);
+		dst->mapped_output = strdup(src->mapped_output);
+	}
+}
+
+struct input_config *copy_input_config(struct input_config *ic) {
+	struct input_config *copy = calloc(1, sizeof(struct input_config));
+	if (copy == NULL) {
+		wlr_log(L_ERROR, "could not allocate input config");
+		return NULL;
+	}
+	merge_input_config(copy, ic);
+	return copy;
+}
+
+void free_input_config(struct input_config *ic) {
+	if (!ic) {
+		return;
+	}
+	free(ic->identifier);
+	free(ic);
+}
+
+int input_identifier_cmp(const void *item, const void *data) {
+	const struct input_config *ic = item;
+	const char *identifier = data;
+	return strcmp(ic->identifier, identifier);
+}
diff --git a/sway/config/output.c b/sway/config/output.c
new file mode 100644
index 00000000..1c298d37
--- /dev/null
+++ b/sway/config/output.c
@@ -0,0 +1,213 @@
+#define _XOPEN_SOURCE 700
+#include <assert.h>
+#include <stdbool.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <wlr/types/wlr_output.h>
+#include <wlr/types/wlr_output_layout.h>
+#include "sway/config.h"
+#include "sway/output.h"
+#include "log.h"
+
+int output_name_cmp(const void *item, const void *data) {
+	const struct output_config *output = item;
+	const char *name = data;
+
+	return strcmp(output->name, name);
+}
+
+void output_get_identifier(char *identifier, size_t len,
+		struct sway_output *output) {
+	struct wlr_output *wlr_output = output->wlr_output;
+	snprintf(identifier, len, "%s %s %s", wlr_output->make, wlr_output->model,
+		wlr_output->serial);
+}
+
+struct output_config *new_output_config(const char *name) {
+	struct output_config *oc = calloc(1, sizeof(struct output_config));
+	if (oc == NULL) {
+		return NULL;
+	}
+	oc->name = strdup(name);
+	if (oc->name == NULL) {
+		free(oc);
+		return NULL;
+	}
+	oc->enabled = -1;
+	oc->width = oc->height = -1;
+	oc->refresh_rate = -1;
+	oc->x = oc->y = -1;
+	oc->scale = -1;
+	oc->transform = -1;
+	return oc;
+}
+
+void merge_output_config(struct output_config *dst, struct output_config *src) {
+	if (src->name) {
+		free(dst->name);
+		dst->name = strdup(src->name);
+	}
+	if (src->enabled != -1) {
+		dst->enabled = src->enabled;
+	}
+	if (src->width != -1) {
+		dst->width = src->width;
+	}
+	if (src->height != -1) {
+		dst->height = src->height;
+	}
+	if (src->x != -1) {
+		dst->x = src->x;
+	}
+	if (src->y != -1) {
+		dst->y = src->y;
+	}
+	if (src->scale != -1) {
+		dst->scale = src->scale;
+	}
+	if (src->refresh_rate != -1) {
+		dst->refresh_rate = src->refresh_rate;
+	}
+	if (src->transform != -1) {
+		dst->transform = src->transform;
+	}
+	if (src->background) {
+		free(dst->background);
+		dst->background = strdup(src->background);
+	}
+	if (src->background_option) {
+		free(dst->background_option);
+		dst->background_option = strdup(src->background_option);
+	}
+}
+
+static void set_mode(struct wlr_output *output, int width, int height,
+		float refresh_rate) {
+	int mhz = (int)(refresh_rate * 1000);
+	if (wl_list_empty(&output->modes)) {
+		wlr_log(L_DEBUG, "Assigning custom mode to %s", output->name);
+		wlr_output_set_custom_mode(output, width, height, mhz);
+		return;
+	}
+
+	struct wlr_output_mode *mode, *best = NULL;
+	wl_list_for_each(mode, &output->modes, link) {
+		if (mode->width == width && mode->height == height) {
+			if (mode->refresh == mhz) {
+				best = mode;
+				break;
+			}
+			best = mode;
+		}
+	}
+	if (!best) {
+		wlr_log(L_ERROR, "Configured mode for %s not available", output->name);
+	} else {
+		wlr_log(L_DEBUG, "Assigning configured mode to %s", output->name);
+		wlr_output_set_mode(output, best);
+	}
+}
+
+void terminate_swaybg(pid_t pid) {
+	int ret = kill(pid, SIGTERM);
+	if (ret != 0) {
+		wlr_log(L_ERROR, "Unable to terminate swaybg [pid: %d]", pid);
+	} else {
+		int status;
+		waitpid(pid, &status, 0);
+	}
+}
+
+void apply_output_config(struct output_config *oc, struct sway_container *output) {
+	assert(output->type == C_OUTPUT);
+
+	struct wlr_output_layout *output_layout =
+		root_container.sway_root->output_layout;
+	struct wlr_output *wlr_output = output->sway_output->wlr_output;
+
+	if (oc && oc->enabled == 0) {
+		container_destroy(output);
+		wlr_output_layout_remove(root_container.sway_root->output_layout,
+			wlr_output);
+		return;
+	}
+
+	if (oc && oc->width > 0 && oc->height > 0) {
+		wlr_log(L_DEBUG, "Set %s mode to %dx%d (%f GHz)", oc->name, oc->width,
+			oc->height, oc->refresh_rate);
+		set_mode(wlr_output, oc->width, oc->height, oc->refresh_rate);
+	}
+	if (oc && oc->scale > 0) {
+		wlr_log(L_DEBUG, "Set %s scale to %f", oc->name, oc->scale);
+		wlr_output_set_scale(wlr_output, oc->scale);
+	}
+	if (oc && oc->transform >= 0) {
+		wlr_log(L_DEBUG, "Set %s transform to %d", oc->name, oc->transform);
+		wlr_output_set_transform(wlr_output, oc->transform);
+	}
+
+	// Find position for it
+	if (oc && (oc->x != -1 || oc->y != -1)) {
+		wlr_log(L_DEBUG, "Set %s position to %d, %d", oc->name, oc->x, oc->y);
+		wlr_output_layout_add(output_layout, wlr_output, oc->x, oc->y);
+	} else {
+		wlr_output_layout_add_auto(output_layout, wlr_output);
+	}
+
+	if (!oc || !oc->background) {
+		// Look for a * config for background
+		int i = list_seq_find(config->output_configs, output_name_cmp, "*");
+		if (i >= 0) {
+			oc = config->output_configs->items[i];
+		} else {
+			oc = NULL;
+		}
+	}
+
+	int output_i;
+	for (output_i = 0; output_i < root_container.children->length; ++output_i) {
+		if (root_container.children->items[output_i] == output) {
+			break;
+		}
+	}
+
+	if (oc && oc->background) {
+		if (output->sway_output->bg_pid != 0) {
+			terminate_swaybg(output->sway_output->bg_pid);
+		}
+
+		wlr_log(L_DEBUG, "Setting background for output %d to %s",
+				output_i, oc->background);
+
+		size_t len = snprintf(NULL, 0, "%s %d %s %s",
+				config->swaybg_command ? config->swaybg_command : "swaybg",
+				output_i, oc->background, oc->background_option);
+		char *command = malloc(len + 1);
+		if (!command) {
+			wlr_log(L_DEBUG, "Unable to allocate swaybg command");
+			return;
+		}
+		snprintf(command, len + 1, "%s %d %s %s",
+				config->swaybg_command ? config->swaybg_command : "swaybg",
+				output_i, oc->background, oc->background_option);
+		wlr_log(L_DEBUG, "-> %s", command);
+
+		char *const cmd[] = { "sh", "-c", command, NULL };
+		output->sway_output->bg_pid = fork();
+		if (output->sway_output->bg_pid == 0) {
+			execvp(cmd[0], cmd);
+		}
+	}
+}
+
+void free_output_config(struct output_config *oc) {
+	if (!oc) {
+		return;
+	}
+	free(oc->name);
+	free(oc->background);
+	free(oc->background_option);
+	free(oc);
+}
diff --git a/sway/config/seat.c b/sway/config/seat.c
new file mode 100644
index 00000000..bd8b45c8
--- /dev/null
+++ b/sway/config/seat.c
@@ -0,0 +1,146 @@
+#define _XOPEN_SOURCE 700
+#include <stdlib.h>
+#include <string.h>
+#include "sway/config.h"
+#include "log.h"
+
+struct seat_config *new_seat_config(const char* name) {
+	struct seat_config *seat = calloc(1, sizeof(struct seat_config));
+	if (!seat) {
+		wlr_log(L_DEBUG, "Unable to allocate seat config");
+		return NULL;
+	}
+
+	wlr_log(L_DEBUG, "new_seat_config(%s)", name);
+	seat->name = strdup(name);
+	if (!sway_assert(seat->name, "could not allocate name for seat")) {
+		free(seat);
+		return NULL;
+	}
+
+	seat->fallback = -1;
+	seat->attachments = create_list();
+	if (!sway_assert(seat->attachments,
+				"could not allocate seat attachments list")) {
+		free(seat->name);
+		free(seat);
+		return NULL;
+	}
+
+	return seat;
+}
+
+struct seat_attachment_config *seat_attachment_config_new() {
+	struct seat_attachment_config *attachment =
+		calloc(1, sizeof(struct seat_attachment_config));
+	if (!attachment) {
+		wlr_log(L_DEBUG, "cannot allocate attachment config");
+		return NULL;
+	}
+	return attachment;
+}
+
+static void seat_attachment_config_free(
+		struct seat_attachment_config *attachment) {
+	free(attachment->identifier);
+	free(attachment);
+	return;
+}
+
+static struct seat_attachment_config *seat_attachment_config_copy(
+		struct seat_attachment_config *attachment) {
+	struct seat_attachment_config *copy = seat_attachment_config_new();
+	if (!copy) {
+		return NULL;
+	}
+
+	copy->identifier = strdup(attachment->identifier);
+
+	return copy;
+}
+
+static void merge_seat_attachment_config(struct seat_attachment_config *dest,
+		struct seat_attachment_config *source) {
+	// nothing to merge yet, but there will be some day
+}
+
+void merge_seat_config(struct seat_config *dest, struct seat_config *source) {
+	if (source->name) {
+		free(dest->name);
+		dest->name = strdup(source->name);
+	}
+
+	if (source->fallback != -1) {
+		dest->fallback = source->fallback;
+	}
+
+	for (int i = 0; i < source->attachments->length; ++i) {
+		struct seat_attachment_config *source_attachment =
+			source->attachments->items[i];
+		bool found = false;
+		for (int j = 0; j < dest->attachments->length; ++j) {
+			struct seat_attachment_config *dest_attachment =
+				dest->attachments->items[j];
+			if (strcmp(source_attachment->identifier,
+						dest_attachment->identifier) == 0) {
+				merge_seat_attachment_config(dest_attachment,
+					source_attachment);
+				found = true;
+			}
+		}
+
+		if (!found) {
+			struct seat_attachment_config *copy =
+				seat_attachment_config_copy(source_attachment);
+			if (copy) {
+				list_add(dest->attachments, copy);
+			}
+		}
+	}
+}
+
+struct seat_config *copy_seat_config(struct seat_config *seat) {
+	struct seat_config *copy = new_seat_config(seat->name);
+	if (copy == NULL) {
+		return NULL;
+	}
+
+	merge_seat_config(copy, seat);
+
+	return copy;
+}
+
+void free_seat_config(struct seat_config *seat) {
+	if (!seat) {
+		return;
+	}
+
+	free(seat->name);
+	for (int i = 0; i < seat->attachments->length; ++i) {
+		struct seat_attachment_config *attachment =
+			seat->attachments->items[i];
+		seat_attachment_config_free(attachment);
+	}
+
+	list_free(seat->attachments);
+	free(seat);
+}
+
+int seat_name_cmp(const void *item, const void *data) {
+	const struct seat_config *sc = item;
+	const char *name = data;
+	return strcmp(sc->name, name);
+}
+
+struct seat_attachment_config *seat_config_get_attachment(
+		struct seat_config *seat_config, char *identifier) {
+	for (int i = 0; i < seat_config->attachments->length; ++i) {
+		struct seat_attachment_config *attachment =
+			seat_config->attachments->items[i];
+		if (strcmp(attachment->identifier, identifier) == 0) {
+			return attachment;
+		}
+	}
+
+	return NULL;
+}