ltk

ltkd.c (58197B)

---

 /* FIXME: Figure out how to properly print window id */
 /* FIXME: error checking in tokenizer (is this necessary?) */
 /* FIXME: strip whitespace at end of lines in socket format */
 /*
  * Copyright (c) 2016-2023 lumidify <nobody@lumidify.org>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 #include <time.h>
 #include <stdio.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <unistd.h>
 #include <signal.h>
 #include <stdint.h>
 #include <locale.h>
 #include <inttypes.h>
 
 #include <sys/un.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/types.h>
 #include <sys/select.h>
 #include <sys/socket.h>
 
 #include "ini.h"
 #include "khash.h"
 
 #include "graphics.h"
 #include "surface_cache.h"
 #include "theme.h"
 #include "memory.h"
 #include "color.h"
 #include "rect.h"
 #include "widget.h"
 #include "ltk.h"
 #include "util.h"
 #include "text.h"
 #include "grid.h"
 /* #include "draw.h" */
 #include "button.h"
 #include "entry.h"
 #include "label.h"
 #include "scrollbar.h"
 #include "box.h"
 #include "menu.h"
 #include "image.h"
 #include "image_widget.h"
 #include "macros.h"
 #include "config.h"
 
 #define MAX_WINDOW_FONT_SIZE 200
 
 #define MAX_SOCK_CONNS 20
 #define READ_BLK_SIZE 128
 #define WRITE_BLK_SIZE 128
 
 struct token_list {
 	ltk_cmd_token *tokens;
 	/* FIXME: size_t everywhere */
 	int num_tokens;
 	int num_alloc;
 };
 
 /* FIXME: switch to size_t */
 static struct ltk_sock_info {
 	int fd;                    /* file descriptor for socket connection */
 	int event_mask;            /* events to send to socket */
 	char *read;                /* text read from socket */
 	int read_len;              /* length of text in read buffer */
 	int read_alloc;            /* size of read buffer */
 	char *to_write;            /* text to be written to socket */
 	int write_len;             /* length of text in write buffer */
 	int write_cur;             /* length of text already written */
 	int write_alloc;           /* size of write buffer */
 	/* stuff for tokenizing */
 	int in_token;              /* last read char is inside token */
 	int offset;                /* offset from removing backslashes */
 	int in_str;                /* last read char is inside string */
 	int read_cur;              /* length of text already tokenized */
 	int bs;                    /* last char was non-escaped backslash */
 	struct token_list tokens;  /* current tokens */
 	uint32_t last_seq;         /* sequence number of last request processed */
 } sockets[MAX_SOCK_CONNS];
 
 typedef struct {
 	void (*callback)(void *);
 	void *data;
 	struct timespec repeat;
 	struct timespec remaining;
 	int id;
 } ltk_timer;
 
 static ltk_timer *timers = NULL;
 static size_t timers_num = 0;
 static size_t timers_alloc = 0;
 
 static int daemonize_flag = 1;
 
 static int ltk_mainloop(ltk_window *window);
 static char *get_sock_path(char *basedir, Window id);
 static FILE *open_log(char *dir);
 static void daemonize(void);
 static ltk_window *ltk_create_window(const char *title, int x, int y,
     unsigned int w, unsigned int h);
 static void ltk_destroy_window(ltk_window *window);
 static void ltk_redraw_window(ltk_window *window);
 static void ltk_window_other_event(ltk_window *window, ltk_event *event);
 static void ltk_handle_event(ltk_window *window, ltk_event *event);
 
 static void ltk_load_theme(ltk_window *window, const char *path);
 static void ltk_uninitialize_theme(ltk_window *window);
 static int ltk_ini_handler(void *window, const char *widget, const char *prop, const char *value);
 static int ltk_window_fill_theme_defaults(ltk_window *window);
 static int ltk_window_ini_handler(ltk_window *window, const char *prop, const char *value);
 static void ltk_window_uninitialize_theme(ltk_window *window);
 
 static int read_sock(struct ltk_sock_info *sock);
 static int push_token(struct token_list *tl, char *token);
 static int read_sock(struct ltk_sock_info *sock);
 static int write_sock(struct ltk_sock_info *sock);
 static int tokenize_command(struct ltk_sock_info *sock);
 static int ltk_set_root_widget_cmd(ltk_window *window, ltk_cmd_token *tokens, int num_tokens, ltk_error *err);
 static int process_commands(ltk_window *window, int client);
 static int add_client(int fd);
 static int listen_sock(const char *sock_path);
 static int accept_sock(int listenfd);
 
 static short maxsocket = -1;
 static short running = 1;
 static short sock_write_available = 0;
 static char *ltk_dir = NULL;
 static FILE *ltk_logfile = NULL;
 static char *sock_path = NULL;
 /* Note: Most functions still take this explicitly because it wasn't
    global originally, but that's just the way it is. */
 static ltk_window *main_window = NULL;
 
 typedef struct {
 	char *name;
 	int (*ini_handler)(ltk_window *, const char *, const char *);
 	int (*fill_theme_defaults)(ltk_window *);
 	void (*uninitialize_theme)(ltk_window *);
 	int (*register_keypress)(const char *, size_t, ltk_keypress_binding);
 	int (*register_keyrelease)(const char *, size_t, ltk_keyrelease_binding);
 	void (*cleanup)(void);
 	int (*cmd)(ltk_window *, ltk_cmd_token *, size_t, ltk_error *);
 } ltk_widget_funcs;
 
 /* FIXME: use binary search when searching for the widget */
 ltk_widget_funcs widget_funcs[] = {
 	{
 		.name = "box",
 		.ini_handler = NULL,
 		.fill_theme_defaults = NULL,
 		.uninitialize_theme = NULL,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = &ltk_box_cmd
 	},
 	{
 		.name = "button",
 		.ini_handler = &ltk_button_ini_handler,
 		.fill_theme_defaults = &ltk_button_fill_theme_defaults,
 		.uninitialize_theme = &ltk_button_uninitialize_theme,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = &ltk_button_cmd
 	},
 	{
 		.name = "entry",
 		.ini_handler = &ltk_entry_ini_handler,
 		.fill_theme_defaults = &ltk_entry_fill_theme_defaults,
 		.uninitialize_theme = &ltk_entry_uninitialize_theme,
 		.register_keypress = &ltk_entry_register_keypress,
 		.register_keyrelease = &ltk_entry_register_keyrelease,
 		.cleanup = &ltk_entry_cleanup,
 		.cmd = &ltk_entry_cmd
 	},
 	{
 		.name = "grid",
 		.ini_handler = NULL,
 		.fill_theme_defaults = NULL,
 		.uninitialize_theme = NULL,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = &ltk_grid_cmd
 	},
 	{
 		.name = "label",
 		.ini_handler = &ltk_label_ini_handler,
 		.fill_theme_defaults = &ltk_label_fill_theme_defaults,
 		.uninitialize_theme = &ltk_label_uninitialize_theme,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = &ltk_label_cmd
 	},
 	{
 		.name = "image",
 		.ini_handler = NULL,
 		.fill_theme_defaults = NULL,
 		.uninitialize_theme = NULL,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = &ltk_image_widget_cmd
 	},
 	{
 		.name = "menu",
 		.ini_handler = &ltk_menu_ini_handler,
 		.fill_theme_defaults = &ltk_menu_fill_theme_defaults,
 		.uninitialize_theme = &ltk_menu_uninitialize_theme,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = &ltk_menu_cmd
 	},
 	{
 		.name = "menuentry",
 		.ini_handler = &ltk_menuentry_ini_handler,
 		.fill_theme_defaults = &ltk_menuentry_fill_theme_defaults,
 		.uninitialize_theme = &ltk_menuentry_uninitialize_theme,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = &ltk_menuentry_cmd
 	},
 	{
 		.name = "submenu",
 		.ini_handler = &ltk_submenu_ini_handler,
 		.fill_theme_defaults = &ltk_submenu_fill_theme_defaults,
 		.uninitialize_theme = &ltk_submenu_uninitialize_theme,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = &ltk_menu_cmd
 	},
 	{
 		.name = "submenuentry",
 		.ini_handler = &ltk_submenuentry_ini_handler,
 		.fill_theme_defaults = &ltk_submenuentry_fill_theme_defaults,
 		.uninitialize_theme = &ltk_submenuentry_uninitialize_theme,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		/* This "widget" is only needed to have separate styles for regular
 		   menu entries and submenu entries. "submenu" is just an alias for
 		   "menu" in most cases - it's just needed when creating a menu to
 		   decide if it's a submenu or not.
 		   FIXME: is that even necessary? Why can't it just decide if it's
 		   a submenu based on whether it has a parent or not?
 		   -> I guess right-click menus are also just submenus, so they
 		   need to set it explicitly, but wasn't there another reaseon? */
 		.cmd = NULL
 	},
 	{
 		.name = "scrollbar",
 		.ini_handler = &ltk_scrollbar_ini_handler,
 		.fill_theme_defaults = &ltk_scrollbar_fill_theme_defaults,
 		.uninitialize_theme = &ltk_scrollbar_uninitialize_theme,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = NULL
 	},
 	{
 		/* Handler for general widget key bindings. */
 		.name = "widget",
 		.ini_handler = NULL,
 		.fill_theme_defaults = NULL,
 		.uninitialize_theme = NULL,
 		.register_keypress = &ltk_widget_register_keypress,
 		.register_keyrelease = &ltk_widget_register_keyrelease,
 		.cleanup = &ltk_widget_cleanup,
 		.cmd = NULL
 	},
 	{
 		/* Handler for window theme. */
 		.name = "window",
 		.ini_handler = &ltk_window_ini_handler,
 		.fill_theme_defaults = &ltk_window_fill_theme_defaults,
 		.uninitialize_theme = &ltk_window_uninitialize_theme,
 		.register_keypress = NULL,
 		.register_keyrelease = NULL,
 		.cleanup = NULL,
 		.cmd = NULL
 	}
 };
 
 int
 main(int argc, char *argv[]) {
 	setlocale(LC_CTYPE, "");
 	XSetLocaleModifiers("");
 	int ch;
 	char *title = "LTK Window";
 	while ((ch = getopt(argc, argv, "dt:")) != -1) {
 		switch (ch) {
 			case 't':
 				title = optarg;
 				break;
 			case 'd':
 				daemonize_flag = 0;
 				break;
 			default:
 				ltk_fatal("USAGE: ltkd [-t title]\n");
 		}
 	}
 
 	ltk_dir = ltk_setup_directory();
 	if (!ltk_dir) ltk_fatal_errno("Unable to setup ltk directory.\n");
 	ltk_logfile = open_log(ltk_dir);
 	if (!ltk_logfile) ltk_fatal_errno("Unable to open log file.\n");
 
 	/* FIXME: move to widget_funcs? */
 	ltk_widgets_init();
 
 	/* FIXME: set window size properly - I only run it in a tiling WM
 	   anyways, so it doesn't matter, but still... */
 	main_window = ltk_create_window(title, 0, 0, 500, 500);
 
 	sock_path = get_sock_path(ltk_dir, renderer_get_window_id(main_window->renderdata));
 	if (!sock_path) ltk_fatal_errno("Unable to allocate memory for socket path.\n");
 
 	/* Note: sockets should be initialized to 0 because it is static */
 	for (int i = 0; i < MAX_SOCK_CONNS; i++) {
 		sockets[i].fd = -1; /* socket unused */
 		/* initialize these just because I'm paranoid */
 		sockets[i].read = NULL;
 		sockets[i].to_write = NULL;
 		sockets[i].tokens.tokens = NULL;
 	}
 
 	return ltk_mainloop(main_window);
 }
 
 /* FIXME: need to recalculate maxfd when removing client */
 static struct {
 	fd_set rallfds, wallfds;
 	int maxfd;
 	int listenfd;
 } sock_state;
 
 /* FIXME: this is extremely dangerous right now because pretty much any command
    can be executed, so for instance the widget that caused the lock could also
    be destroyed, causing issues when this function returns */
 int
 ltk_handle_lock_client(ltk_window *window, int client) {
 	if (client < 0 || client >= MAX_SOCK_CONNS || sockets[client].fd == -1)
 		return 0;
 	fd_set rfds, wfds, rallfds, wallfds;
 	int clifd = sockets[client].fd;
 	FD_ZERO(&rallfds);
 	FD_ZERO(&wallfds);
 	FD_SET(clifd, &rallfds);
 	FD_SET(clifd, &wallfds);
 	int retval;
 	struct timeval tv;
 	tv.tv_sec = 0;
 	tv.tv_usec = 0;
 	struct timespec now, elapsed, last, sleep_time;
 	clock_gettime(CLOCK_MONOTONIC, &last);
 	sleep_time.tv_sec = 0;
 	while (1) {
 		rfds = rallfds;
 		wfds = wallfds;
 		retval = select(clifd + 1, &rfds, &wfds, NULL, &tv);
 
 		if (retval > 0) {
 			if (FD_ISSET(clifd, &rfds)) {
 				int ret;
 				while ((ret = read_sock(&sockets[client])) == 1) {
 					int pret;
 					if ((pret = process_commands(window, client)) == 1)
 						return 1;
 					else if (pret == -1)
 						return 0;
 				}
 				/* FIXME: maybe also return on read error? or would that be dangerous? */
 				if (ret == 0) {
 					FD_CLR(clifd, &sock_state.rallfds);
 					FD_CLR(clifd, &sock_state.wallfds);
 					ltk_widget_remove_client(client);
 					sockets[clifd].fd = -1;
 					close(clifd);
 					int newmaxsocket = -1;
 					for (int j = 0; j <= maxsocket; j++) {
 						if (sockets[j].fd >= 0)
 							newmaxsocket = j;
 					}
 					maxsocket = newmaxsocket;
 					if (maxsocket == -1) {
 						ltk_quit(window);
 						break;
 					}
 					return 0;
 				}
 			}
 			if (FD_ISSET(clifd, &wfds)) {
 				/* FIXME: call in loop like above */
 				write_sock(&sockets[client]);
 			}
 		}
 		clock_gettime(CLOCK_MONOTONIC, &now);
 		ltk_timespecsub(&now, &last, &elapsed);
 		/* FIXME: configure framerate */
 		if (elapsed.tv_sec == 0 && elapsed.tv_nsec < 20000000LL) {
 			sleep_time.tv_nsec = 20000000LL - elapsed.tv_nsec;
 			nanosleep(&sleep_time, NULL);
 		}
 		last = now;
 	}
 	return 0;
 }
 
 static int
 ltk_mainloop(ltk_window *window) {
 	ltk_event event;
 	fd_set rfds, wfds;
 	int retval;
 	int clifd;
 	struct timeval tv;
 	tv.tv_sec = 0;
 	tv.tv_usec = 0;
 
 	FD_ZERO(&sock_state.rallfds);
 	FD_ZERO(&sock_state.wallfds);
 
 	if ((sock_state.listenfd = listen_sock(sock_path)) < 0)
 		ltk_fatal_errno("Error listening on socket.\n");
 
 	FD_SET(sock_state.listenfd, &sock_state.rallfds);
 	sock_state.maxfd = sock_state.listenfd;
 
 	printf("%lu", renderer_get_window_id(main_window->renderdata));
 	fflush(stdout);
 	if (daemonize_flag)
 		daemonize();
 
 	/* FIXME: make time management smarter - maybe always figure out how long
 	   it will take until the next timer is due and then sleep if no other events
 	   are happening */
 	struct timespec now, elapsed, last, lasttimer, sleep_time;
 	clock_gettime(CLOCK_MONOTONIC, &last);
 	lasttimer = last;
 	sleep_time.tv_sec = 0;
 
 	/* initialize keyboard mapping */
 	ltk_generate_keyboard_event(window->renderdata, &event);
 	ltk_handle_event(window, &event);
 
 	int pid = -1;
 	int wstatus = 0;
 	while (running) {
 		if (window->cmd_caller && (pid = waitpid(window->cmd_pid, &wstatus, WNOHANG)) > 0) {
 			ltk_error err;
 			ltk_widget *cmd_caller = ltk_get_widget(window->cmd_caller, LTK_WIDGET_ANY, &err);
 			/* FIXME: should commands be split into read/write and block write commands during external editing? */
 			/* FIXME: what if a new widget with same id was created in meantime? */
 			if (!cmd_caller) {
 				ltk_warn("Widget '%s' disappeared while text was being edited in external program\n", window->cmd_caller);
 			} else if (cmd_caller->vtable->cmd_return) {
 				size_t file_len = 0;
 				char *errstr = NULL;
 				char *contents = ltk_read_file(window->cmd_tmpfile, &file_len, &errstr);
 				if (!contents) {
 					ltk_warn("Unable to read file '%s' written by external command: %s\n", window->cmd_tmpfile, errstr);
 				} else {
 					cmd_caller->vtable->cmd_return(cmd_caller, contents, file_len);
 					ltk_free(contents);
 				}
 			}
 			ltk_free(window->cmd_caller);
 			window->cmd_caller = NULL;
 			window->cmd_pid = -1;
 			unlink(window->cmd_tmpfile);
 			ltk_free(window->cmd_tmpfile);
 			window->cmd_tmpfile = NULL;
 		}
 		rfds = sock_state.rallfds;
 		wfds = sock_state.wallfds;
 		retval = select(sock_state.maxfd + 1, &rfds, &wfds, NULL, &tv);
 		while (!ltk_next_event(window->renderdata, window->clipboard, window->cur_kbd, &event))
 			ltk_handle_event(window, &event);
 
 		if (retval > 0) {
 			if (FD_ISSET(sock_state.listenfd, &rfds)) {
 				if ((clifd = accept_sock(sock_state.listenfd)) < 0) {
 					/* FIXME: Just log this! */
 					ltk_fatal_errno("Error accepting socket connection.\n");
 				}
 				int i = add_client(clifd);
 				FD_SET(clifd, &sock_state.rallfds);
 				FD_SET(clifd, &sock_state.wallfds);
 				if (clifd > sock_state.maxfd)
 					sock_state.maxfd = clifd;
 				if (i > maxsocket)
 					maxsocket = i;
 				continue;
 			}
 			for (int i = 0; i <= maxsocket; i++) {
 				if ((clifd = sockets[i].fd) < 0)
 					continue;
 				if (FD_ISSET(clifd, &rfds)) {
 					/* FIXME: better error handling - this assumes error
 					   is always because read would block */
 					/* FIXME: maybe maximum number of iterations here to
 					   avoid choking on a lot of data? although such a
 					   large amount of data would probably cause other
 					   problems anyways */
 					/* or maybe measure time and break after max time? */
 					int ret;
 					while ((ret = read_sock(&sockets[i])) == 1) {
 						process_commands(window, i);
 					}
 					if (ret == 0) {
 						ltk_widget_remove_client(i);
 						FD_CLR(clifd, &sock_state.rallfds);
 						FD_CLR(clifd, &sock_state.wallfds);
 						sockets[i].fd = -1;
 						/* FIXME: what to do on error? */
 						close(clifd);
 						int newmaxsocket = -1;
 						for (int j = 0; j <= maxsocket; j++) {
 							if (sockets[j].fd >= 0)
 								newmaxsocket = j;
 						}
 						maxsocket = newmaxsocket;
 						if (maxsocket == -1) {
 							ltk_quit(window);
 							break;
 						}
 					}
 				}
 				/* FIXME: maybe ignore SIGPIPE signal - then don't call FD_CLR
 				   for wallfds above but rather when write fails with EPIPE */
 				/* -> this would possibly allow data to be written still in the
 				   hypothetical scenario that only the writing end of the socket
 				   is closed (and ltkd wouldn't crash if only the reading end is
 				   closed) */
 				if (FD_ISSET(clifd, &wfds)) {
 					/* FIXME: also call in loop like reading above */
 					write_sock(&sockets[i]);
 				}
 			}
 		}
 
 		clock_gettime(CLOCK_MONOTONIC, &now);
 		ltk_timespecsub(&now, &lasttimer, &elapsed);
 		/* Note: it should be safe to give the same pointer as the first and
 		   last argument, as long as ltk_timespecsub/add isn't changed incompatibly */
 		size_t i = 0;
 		while (i < timers_num) {
 			ltk_timespecsub(&timers[i].remaining, &elapsed, &timers[i].remaining);
 			if (timers[i].remaining.tv_sec < 0 ||
 			    (timers[i].remaining.tv_sec == 0 && timers[i].remaining.tv_nsec == 0)) {
 				timers[i].callback(timers[i].data);
 				if (timers[i].repeat.tv_sec == 0 && timers[i].repeat.tv_nsec == 0) {
 					/* remove timer because it has no repeat */
 					memmove(timers + i, timers + i + 1, sizeof(ltk_timer) * (timers_num - i - 1));
 				} else {
 					ltk_timespecadd(&timers[i].remaining, &timers[i].repeat, &timers[i].remaining);
 					i++;
 				}
 			} else {
 				i++;
 			}
 		}
 		lasttimer = now;
 
 		if (window->dirty_rect.w != 0 && window->dirty_rect.h != 0) {
 			ltk_redraw_window(window);
 			window->dirty_rect.w = 0;
 			window->dirty_rect.h = 0;
 		}
 
 		clock_gettime(CLOCK_MONOTONIC, &now);
 		ltk_timespecsub(&now, &last, &elapsed);
 		/* FIXME: configure framerate */
 		if (elapsed.tv_sec == 0 && elapsed.tv_nsec < 20000000LL) {
 			sleep_time.tv_nsec = 20000000LL - elapsed.tv_nsec;
 			nanosleep(&sleep_time, NULL);
 		}
 		last = now;
 	}
 
 	ltk_cleanup();
 
 	return 0;
 }
 
 /* largely copied from APUE... */
 /* am I breaking copyright here? */
 static void
 daemonize(void) {
 	pid_t pid;
 	struct sigaction sa;
 
 	fflush(stdout);
 	fflush(stderr);
 	fflush(ltk_logfile);
 
 	if ((pid = fork()) < 0)
 		ltk_fatal_errno("Can't fork.\n");
 	else if (pid != 0)
 		exit(0);
 	setsid();
 
 	sa.sa_handler = SIG_IGN;
 	sigemptyset(&sa.sa_mask);
 	sa.sa_flags = 0;
 	if (sigaction(SIGHUP, &sa, NULL) < 0)
 		ltk_fatal_errno("Unable to ignore SIGHUP.\n");
 	if ((pid  = fork()) < 0)
 		ltk_fatal_errno("Can't fork.\n");
 	else if (pid != 0)
 		exit(0);
 
 	if (chdir("/") < 0)
 		ltk_fatal_errno("Can't change directory to root.\n");
 
 	/* FIXME: why didn't I just use fclose() here? */
 	/* FIXME: just print log to stdout and let this take care of redirection */
 	close(fileno(stdin));
 	/*close(fileno(stdout));
 	close(fileno(stderr));*/
 	open("/dev/null", O_RDWR);
 	/*dup(0);
 	dup(0);*/
 	dup2(fileno(ltk_logfile), fileno(stdout));
 	dup2(fileno(ltk_logfile), fileno(stderr));
 
 	/* FIXME: Is it guaranteed that this will work? Will these fds
 	   always be opened on the lowest numbers? */
 }
 
 static char *
 get_sock_path(char *basedir, Window id) {
 	int len;
 	char *path;
 
 	len = strlen(basedir);
 	/* FIXME: MAKE SURE THIS IS ACTUALLY BIG ENOUGH! */
 	path = ltk_malloc(len + 20);
 	/* FIXME: also check for less than 0 */
 	if (snprintf(path, len + 20, "%s/%lu.sock", basedir, id) >= len + 20)
 		ltk_fatal("Tell lumidify to fix his code.\n");
 
 	return path;
 }
 
 static FILE *
 open_log(char *dir) {
 	FILE *f;
 	char *path;
 
 	path = ltk_strcat_useful(dir, "/ltkd.log");
 	if (!path)
 		return NULL;
 	f = fopen(path, "a");
 	if (!f) {
 		ltk_free(path);
 		return NULL;
 	}
 	ltk_free(path);
 
 	return f;
 }
 
 void
 ltk_cleanup(void) {
 	if (sock_state.listenfd >= 0)
 		close(sock_state.listenfd);
 	if (ltk_dir)
 		ltk_free(ltk_dir);
 	if (ltk_logfile)
 		fclose(ltk_logfile);
 	if (sock_path) {
 		unlink(sock_path);
 		ltk_free(sock_path);
 	}
 
 	for (int i = 0; i < MAX_SOCK_CONNS; i++) {
 		if (sockets[i].fd >= 0)
 			close(sockets[i].fd);
 		if (sockets[i].read)
 			ltk_free(sockets[i].read);
 		if (sockets[i].to_write)
 			ltk_free(sockets[i].to_write);
 		if (sockets[i].tokens.tokens)
 			ltk_free(sockets[i].tokens.tokens);
 	}
 
 	ltk_config_cleanup();
 	for (size_t i = 0; i < LENGTH(widget_funcs); i++) {
 		if (widget_funcs[i].cleanup)
 			widget_funcs[i].cleanup();
 	}
 	ltk_events_cleanup();
 	if (main_window) {
 		ltk_uninitialize_theme(main_window);
 		ltk_destroy_window(main_window);
 	}
 	main_window = NULL;
 }
 
 void
 ltk_quit(ltk_window *window) {
 	(void)window;
 	running = 0;
 }
 
 void
 ltk_log_msg(const char *mode, const char *format, va_list args) {
 	char logtime[25]; /* FIXME: This should always be big enough, right? */
 	time_t clock;
 	struct tm *timeptr;
 
 	time(&clock);
 	timeptr = localtime(&clock);
 	strftime(logtime, 25, "%Y-%m-%d %H:%M:%S", timeptr);
 
 	if (main_window)
 		fprintf(stderr, "%s ltkd(%lu) %s: ", logtime, renderer_get_window_id(main_window->renderdata), mode);
 	else
 		fprintf(stderr, "%s ltkd(?) %s: ", logtime, mode);
 	vfprintf(stderr, format, args);
 }
 
 static int
 ltk_set_root_widget_cmd(
     ltk_window *window,
     ltk_cmd_token *tokens,
     int num_tokens,
     ltk_error *err) {
 	ltk_widget *widget;
 	if (num_tokens != 2) {
 		err->type = ERR_INVALID_NUMBER_OF_ARGUMENTS;
 		err->arg = -1;
 		return 1;
 	} else if (tokens[1].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 1;
 		return 1;
 	}
 	widget = ltk_get_widget(tokens[1].text, LTK_WIDGET_ANY, err);
 	if (!widget) {
 		err->arg = 1;
 		return 1;
 	}
 	window->root_widget = widget;
 	widget->lrect.x = 0;
 	widget->lrect.y = 0;
 	widget->lrect.w = window->rect.w;
 	widget->lrect.h = window->rect.h;
 	widget->crect = widget->lrect;
 	ltk_window_invalidate_rect(window, widget->lrect);
 	ltk_widget_resize(widget);
 
 	return 0;
 }
 
 void
 ltk_window_invalidate_rect(ltk_window *window, ltk_rect rect) {
 	if (window->dirty_rect.w == 0 && window->dirty_rect.h == 0)
 		window->dirty_rect = rect;
 	else
 		window->dirty_rect = ltk_rect_union(rect, window->dirty_rect);
 }
 
 ltk_point
 ltk_widget_pos_to_global(ltk_widget *widget, int x, int y) {
 	ltk_widget *cur = widget;
 	while (cur) {
 		x += cur->lrect.x;
 		y += cur->lrect.y;
 		if (cur->popup)
 			break;
 		cur = cur->parent;
 	}
 	return (ltk_point){x, y};
 }
 
 ltk_point
 ltk_global_to_widget_pos(ltk_widget *widget, int x, int y) {
 	ltk_widget *cur = widget;
 	while (cur) {
 		x -= cur->lrect.x;
 		y -= cur->lrect.y;
 		if (cur->popup)
 			break;
 		cur = cur->parent;
 	}
 	return (ltk_point){x, y};
 }
 
 void
 ltk_window_invalidate_widget_rect(ltk_window *window, ltk_widget *widget) {
 	ltk_point glob = ltk_widget_pos_to_global(widget, 0, 0);
 	ltk_window_invalidate_rect(window, (ltk_rect){glob.x, glob.y, widget->lrect.w, widget->lrect.h});
 }
 
 /* FIXME: generic event handling functions that take the actual uint32_t event type, etc. */
 int
 ltk_queue_specific_event(ltk_widget *widget, const char *type, uint32_t mask, const char *data) {
 	int lock_client = -1;
 	for (size_t i = 0; i < widget->masks_num; i++) {
 		if (widget->event_masks[i].lwmask & mask) {
 			ltk_queue_sock_write_fmt(
 			    widget->event_masks[i].client,
 			    "eventl %s %s %s\n", widget->id, type, data
 			);
 			lock_client = widget->event_masks[i].client;
 		} else if (widget->event_masks[i].wmask & mask) {
 			ltk_queue_sock_write_fmt(
 			    widget->event_masks[i].client,
 			    "event %s %s %s\n", widget->id, type, data
 			);
 		}
 	}
 	if (lock_client >= 0) {
 		if (ltk_handle_lock_client(widget->window, lock_client))
 			return 1;
 	}
 	return 0;
 }
 
 static void
 ltk_redraw_window(ltk_window *window) {
 	ltk_widget *ptr;
 	if (!window) return;
 	if (window->dirty_rect.x >= window->rect.w) return;
 	if (window->dirty_rect.y >= window->rect.h) return;
 	if (window->dirty_rect.x + window->dirty_rect.w > window->rect.w)
 		window->dirty_rect.w -= window->dirty_rect.x + window->dirty_rect.w - window->rect.w;
 	if (window->dirty_rect.y + window->dirty_rect.h > window->rect.h)
 		window->dirty_rect.h -= window->dirty_rect.y + window->dirty_rect.h - window->rect.h;
 	/* FIXME: this should use window->dirty_rect, but that doesn't work
 	   properly with double buffering */
 	ltk_surface_fill_rect(window->surface, &window->theme->bg, (ltk_rect){0, 0, window->rect.w, window->rect.h});
 	if (window->root_widget) {
 		ptr = window->root_widget;
 		ptr->vtable->draw(ptr, window->surface, 0, 0, window->rect);
 	}
 	/* last popup is the newest one, so draw that last */
 	for (size_t i = 0; i < window->popups_num; i++) {
 		ptr = window->popups[i];
 		ptr->vtable->draw(ptr, window->surface, ptr->lrect.x, ptr->lrect.y, ltk_rect_relative(ptr->lrect, window->rect));
 	}
 	renderer_swap_buffers(window->renderdata);
 }
 
 static void
 ltk_window_other_event(ltk_window *window, ltk_event *event) {
 	ltk_widget *ptr = window->root_widget;
 	if (event->type == LTK_CONFIGURE_EVENT) {
 		ltk_window_unregister_all_popups(window);
 		int w, h;
 		w = event->configure.w;
 		h = event->configure.h;
 		int orig_w = window->rect.w;
 		int orig_h = window->rect.h;
 		if (orig_w != w || orig_h != h) {
 			window->rect.w = w;
 			window->rect.h = h;
 			ltk_window_invalidate_rect(window, window->rect);
 			ltk_surface_update_size(window->surface, w, h);
 			if (ptr) {
 				ptr->lrect.w = w;
 				ptr->lrect.h = h;
 				ptr->crect = ptr->lrect;
 				ltk_widget_resize(ptr);
 			}
 		}
 	} else if (event->type == LTK_EXPOSE_EVENT) {
 		ltk_rect r;
 		r.x = event->expose.x;
 		r.y = event->expose.y;
 		r.w = event->expose.w;
 		r.h = event->expose.h;
 		ltk_window_invalidate_rect(window, r);
 	} else if (event->type == LTK_WINDOWCLOSE_EVENT) {
 		ltk_quit(window);
 	}
 }
 
 /* FIXME: optimize timer handling - maybe also a sort of priority queue */
 /* FIXME: JUST USE A GENERIC DYNAMIC ARRAY ALREADY!!!!! */
 void
 ltk_unregister_timer(int timer_id) {
 	for (size_t i = 0; i < timers_num; i++) {
 		if (timers[i].id == timer_id) {
 			memmove(
 			    timers + i,
 			    timers + i + 1,
 			    sizeof(ltk_timer) * (timers_num - i - 1)
 			);
 			timers_num--;
 			size_t sz = ideal_array_size(timers_alloc, timers_num);
 			if (sz != timers_alloc) {
 				timers_alloc = sz;
 				timers = ltk_reallocarray(
 				    timers, sz, sizeof(ltk_timer)
 				);
 			}
 			return;
 		}
 	}
 }
 
 /* repeat <= 0 means no repeat, first <= 0 means run as soon as possible */
 int
 ltk_register_timer(long first, long repeat, void (*callback)(void *), void *data) {
 	if (first < 0)
 		first = 0;
 	if (repeat < 0)
 		repeat = 0;
 	if (timers_num == timers_alloc) {
 		timers_alloc = ideal_array_size(timers_alloc, timers_num + 1);
 		timers = ltk_reallocarray(
 		    timers, timers_alloc, sizeof(ltk_timer)
 		);
 	}
 	/* FIXME: better finding of id */
 	/* FIXME: maybe store sorted by id */
 	int id = 0;
 	for (size_t i = 0; i < timers_num; i++) {
 		if (timers[i].id >= id)
 			id = timers[i].id + 1;
 	}
 	ltk_timer *t = &timers[timers_num++];
 	t->callback = callback;
 	t->data = data;
 	t->repeat.tv_sec = repeat / 1000;
 	t->repeat.tv_nsec = (repeat % 1000) * 1000;
 	t->remaining.tv_sec = first / 1000;
 	t->remaining.tv_nsec = (first % 1000) * 1000;
 	t->id = id;
 	return id;
 }
 
 /* FIXME: check for duplicates? */
 void
 ltk_window_register_popup(ltk_window *window, ltk_widget *popup) {
 	if (window->popups_num == window->popups_alloc) {
 		window->popups_alloc = ideal_array_size(
 		    window->popups_alloc, window->popups_num + 1
 		);
 		window->popups = ltk_reallocarray(
 		    window->popups, window->popups_alloc, sizeof(ltk_widget *)
 		);
 	}
 	window->popups[window->popups_num++] = popup;
 	popup->popup = 1;
 }
 
 void
 ltk_window_unregister_popup(ltk_window *window, ltk_widget *popup) {
 	if (window->popups_locked)
 		return;
 	for (size_t i = 0; i < window->popups_num; i++) {
 		if (window->popups[i] == popup) {
 			popup->popup = 0;
 			memmove(
 			    window->popups + i,
 			    window->popups + i + 1,
 			    sizeof(ltk_widget *) * (window->popups_num - i - 1)
 			);
 			window->popups_num--;
 			size_t sz = ideal_array_size(
 			    window->popups_alloc, window->popups_num
 			);
 			if (sz != window->popups_alloc) {
 				window->popups_alloc = sz;
 				window->popups = ltk_reallocarray(
 				    window->popups, sz, sizeof(ltk_widget *)
 				);
 			}
 			return;
 		}
 	}
 }
 
 /* FIXME: where should actual hiding happen? */
 void
 ltk_window_unregister_all_popups(ltk_window *window) {
 	window->popups_locked = 1;
 	for (size_t i = 0; i < window->popups_num; i++) {
 		window->popups[i]->hidden = 1;
 		window->popups[i]->popup = 0;
 		ltk_widget_hide(window->popups[i]);
 	}
 	window->popups_num = 0;
 	/* somewhat arbitrary, but should be enough for most cases */
 	if (window->popups_num > 4) {
 		window->popups = ltk_reallocarray(
 		    window->popups, 4, sizeof(ltk_widget *)
 		);
 		window->popups_alloc = 4;
 	}
 	window->popups_locked = 0;
 	/* I guess just invalidate everything instead of being smart */
 	ltk_window_invalidate_rect(window, window->rect);
 }
 
 ltk_window_theme window_theme;
 static ltk_theme_parseinfo theme_parseinfo[] = {
 	{"font-size", THEME_INT, {.i = &window_theme.font_size}, {.i = 15}, 0, MAX_WINDOW_FONT_SIZE, 0},
 	{"font", THEME_STRING, {.str = &window_theme.font}, {.str = "Liberation Mono"}, 0, 0, 0},
 	{"bg", THEME_COLOR, {.color = &window_theme.bg}, {.color = "#000000"}, 0, 0, 0},
 	{"fg", THEME_COLOR, {.color = &window_theme.fg}, {.color = "#FFFFFF"}, 0, 0, 0},
 };
 static int theme_parseinfo_sorted = 0;
 
 static int
 ltk_window_fill_theme_defaults(ltk_window *window) {
 	return ltk_theme_fill_defaults(window, "window", theme_parseinfo, LENGTH(theme_parseinfo));
 }
 
 static int
 ltk_window_ini_handler(ltk_window *window, const char *prop, const char *value) {
 	return ltk_theme_handle_value(window, "window", prop, value, theme_parseinfo, LENGTH(theme_parseinfo), &theme_parseinfo_sorted);
 }
 
 static void
 ltk_window_uninitialize_theme(ltk_window *window) {
 	ltk_theme_uninitialize(window, theme_parseinfo, LENGTH(theme_parseinfo));
 }
 
 /* FIXME: standardize return codes - usually, 0 is returned on success, but ini.h
    uses 1 on success, so this is all a bit confusing */
 /* FIXME: switch away from ini.h */
 static int
 ltk_ini_handler(void *window, const char *widget, const char *prop, const char *value) {
 	for (size_t i = 0; i < LENGTH(widget_funcs); i++) {
 		if (widget_funcs[i].ini_handler && !strcmp(widget, widget_funcs[i].name)) {
 			widget_funcs[i].ini_handler(window, prop, value);
 			return 1;
 		}
 	}
 	return 0;
 }
 
 static void
 ltk_load_theme(ltk_window *window, const char *path) {
 	/* FIXME: give line number in error message */
 	if (ini_parse(path, ltk_ini_handler, window) != 0) {
 		ltk_warn("Unable to load theme.\n");
 	}
 	for (size_t i = 0; i < LENGTH(widget_funcs); i++) {
 		if (widget_funcs[i].fill_theme_defaults) {
 			if (widget_funcs[i].fill_theme_defaults(window)) {
 				ltk_uninitialize_theme(window);
 				ltk_fatal("Unable to load theme defaults.\n");
 			}
 		}
 	}
 }
 
 static void
 ltk_uninitialize_theme(ltk_window *window) {
 	for (size_t i = 0; i < LENGTH(widget_funcs); i++) {
 		if (widget_funcs[i].uninitialize_theme)
 			widget_funcs[i].uninitialize_theme(window);
 	}
 }
 
 static int
 handle_keypress_binding(const char *widget_name, size_t wlen, const char *name, size_t nlen, ltk_keypress_binding b) {
 	for (size_t i = 0; i < LENGTH(widget_funcs); i++) {
 		if (str_array_equal(widget_funcs[i].name, widget_name, wlen)) {
 			if (!widget_funcs[i].register_keypress)
 				return 1;
 			return widget_funcs[i].register_keypress(name, nlen, b);
 		}
 	}
 	return 1;
 }
 
 static int
 handle_keyrelease_binding(const char *widget_name, size_t wlen, const char *name, size_t nlen, ltk_keyrelease_binding b) {
 	for (size_t i = 0; i < LENGTH(widget_funcs); i++) {
 		if (str_array_equal(widget_funcs[i].name, widget_name, wlen)) {
 			if (!widget_funcs[i].register_keyrelease)
 				return 1;
 			return widget_funcs[i].register_keyrelease(name, nlen, b);
 		}
 	}
 	return 1;
 }
 
 int
 ltk_window_call_cmd(ltk_window *window, ltk_widget *caller, const char *cmd, size_t cmdlen, const char *text, size_t textlen) {
 	if (window->cmd_caller) {
 		/* FIXME: allow multiple programs? */
 		ltk_warn("External program to edit text is already being run\n");
 		return 1;
 	}
 	/* FIXME: support environment variable $TMPDIR */
 	ltk_free(window->cmd_tmpfile);
 	window->cmd_tmpfile = ltk_strdup("/tmp/ltk.XXXXXX");
 	int fd = mkstemp(window->cmd_tmpfile);
 	if (fd == -1) {
 		ltk_warn("Unable to create temporary file while trying to run command '%.*s'\n", (int)cmdlen, cmd);
 		return 1;
 	}
 	close(fd);
 	/* FIXME: give file descriptor directly to modified version of ltk_write_file */
 	char *errstr = NULL;
 	if (ltk_write_file(window->cmd_tmpfile, text, textlen, &errstr)) {
 		ltk_warn("Unable to write to file '%s' while trying to run command '%.*s': %s\n", window->cmd_tmpfile, (int)cmdlen, cmd, errstr);
 		unlink(window->cmd_tmpfile);
 		return 1;
 	}
 	int pid = -1;
 	if ((pid = ltk_parse_run_cmd(cmd, cmdlen, window->cmd_tmpfile)) <= 0) {
 		ltk_warn("Unable to run command '%.*s'\n", (int)cmdlen, cmd);
 		unlink(window->cmd_tmpfile);
 		return 1;
 	}
 	window->cmd_pid = pid;
 	window->cmd_caller = ltk_strdup(caller->id);
 	return 0;
 }
 
 static ltk_window *
 ltk_create_window(const char *title, int x, int y, unsigned int w, unsigned int h) {
 	char *theme_path;
 
 	ltk_window *window = ltk_malloc(sizeof(ltk_window));
 
 	window->popups = NULL;
 	window->popups_num = window->popups_alloc = 0;
 	window->popups_locked = 0;
 	window->cur_kbd = 0;
 
 	window->renderdata = renderer_create_window(title, x, y, w, h);
 	/* FIXME: search different directories for config */
 	char *config_path = ltk_strcat_useful(ltk_dir, "/ltk.cfg");
 	char *errstr = NULL;
 	if (ltk_config_parsefile(config_path, &handle_keypress_binding, &handle_keyrelease_binding, &errstr)) {
 		if (errstr) {
 			ltk_warn("Unable to load config: %s\n", errstr);
 			ltk_free(errstr);
 		}
 		if (ltk_config_load_default(&handle_keypress_binding, &handle_keyrelease_binding, &errstr)) {
 			/* FIXME: I guess errstr isn't freed here, but whatever */
 			ltk_fatal("Unable to load default config: %s\n", errstr);
 		}
 	}
 	ltk_free(config_path);
 	theme_path = ltk_strcat_useful(ltk_dir, "/theme.ini");
 	window->theme = &window_theme;
 	ltk_load_theme(window, theme_path);
 	ltk_free(theme_path);
 
 	/* FIXME: fix theme memory leaks when exit happens between here and the end of this function */
 
 	renderer_set_window_properties(window->renderdata, &window->theme->bg);
 
 	window->root_widget = NULL;
 	window->hover_widget = NULL;
 	window->active_widget = NULL;
 	window->pressed_widget = NULL;
 
 	window->cmd_pid = -1;
 	window->cmd_tmpfile = NULL;
 	window->cmd_caller = NULL;
 
 	window->surface_cache = ltk_surface_cache_create(window->renderdata);
 
 	window->other_event = &ltk_window_other_event;
 
 	window->rect.w = w;
 	window->rect.h = h;
 	window->rect.x = 0;
 	window->rect.y = 0;
 	window->dirty_rect.w = 0;
 	window->dirty_rect.h = 0;
 	window->dirty_rect.x = 0;
 	window->dirty_rect.y = 0;
 	window->surface = ltk_surface_from_window(window->renderdata, w, h);
 
 	window->text_context = ltk_text_context_create(window->renderdata, window->theme->font);
 	window->clipboard = ltk_clipboard_create(window->renderdata);
 
 	/* This hack is necessary to make the daemonization work properly when using Pango.
 	   This may not be entirely accurate, but from what I gather, newer versions of Pango
 	   initialize Fontconfig in a separate thread to avoid startup overhead. This leads
 	   to non-deterministic behavior because the Fontconfig initialization doesn't work
 	   properly after daemonization. Creating a text line and getting the size waits until
 	   Fontconfig is initialized. Getting the size is important because Pango doesn't
 	   actually do much until you try to use the line for something. */
 	/* FIXME: I guess just calling FcInit manually in the text backend could work as well. */
 	/* FIXME: Maybe just call this when actually daemonizing. */
 	ltk_text_line *tmp = ltk_text_line_create(window->text_context, 10, "hi", 0, -1);
 	int tw, th;
 	ltk_text_line_get_size(tmp, &tw, &th);
 	ltk_text_line_destroy(tmp);
 	/* FIXME: cache doesn't really make any sense right now anyways
 	   since images are only loaded from memory */
 	ltk_image_init(window->renderdata, 0);
 
 	return window;
 }
 
 static void
 ltk_destroy_window(ltk_window *window) {
 	ltk_free(window->cmd_tmpfile);
 	ltk_clipboard_destroy(window->clipboard);
 	ltk_text_context_destroy(window->text_context);
 	if (window->popups)
 		ltk_free(window->popups);
 	ltk_surface_cache_destroy(window->surface_cache);
 	ltk_surface_destroy(window->surface);
 	renderer_destroy_window(window->renderdata);
 	ltk_free(window);
 }
 
 /* event must have global coordinates! */
 void
 ltk_window_set_hover_widget(ltk_window *window, ltk_widget *widget, ltk_motion_event *event) {
 	ltk_widget *old = window->hover_widget;
 	if (old == widget)
 		return;
 	int orig_x = event->x, orig_y = event->y;
 	if (old) {
 		ltk_widget_state old_state = old->state;
 		old->state &= ~LTK_HOVER;
 		ltk_widget_change_state(old, old_state);
 		if (old->vtable->mouse_leave) {
 			ltk_point local = ltk_global_to_widget_pos(old, event->x, event->y);
 			event->x = local.x;
 			event->y = local.y;
 			old->vtable->mouse_leave(old, event);
 			event->x = orig_x;
 			event->y = orig_y;
 		}
 	}
 	window->hover_widget = widget;
 	if (widget) {
 		if (widget->vtable->mouse_enter) {
 			ltk_point local = ltk_global_to_widget_pos(widget, event->x, event->y);
 			event->x = local.x;
 			event->y = local.y;
 			widget->vtable->mouse_enter(widget, event);
 		}
 		ltk_widget_state old_state = widget->state;
 		widget->state |= LTK_HOVER;
 		ltk_widget_change_state(widget, old_state);
 		if ((widget->vtable->flags & LTK_HOVER_IS_ACTIVE) && widget != window->active_widget)
 			ltk_window_set_active_widget(window, widget);
 	}
 }
 
 void
 ltk_window_set_active_widget(ltk_window *window, ltk_widget *widget) {
 	if (window->active_widget == widget) {
 		return;
 	}
 	ltk_widget *old = window->active_widget;
 	/* Note: this has to be set at the beginning to
 	   avoid infinite recursion in some cases */
 	window->active_widget = widget;
 	ltk_widget *common_parent = NULL;
 	if (widget) {
 		ltk_widget *cur = widget;
 		while (cur) {
 			if (cur->state & LTK_ACTIVE) {
 				common_parent = cur;
 				break;
 			}
 			ltk_widget_state old_state = cur->state;
 			cur->state |= LTK_ACTIVE;
 			/* FIXME: should all be set focused? */
 			if (cur == widget && !(cur->vtable->flags & LTK_NEEDS_KEYBOARD))
 				widget->state |= LTK_FOCUSED;
 			ltk_widget_change_state(cur, old_state);
 			cur = cur->parent;
 		}
 	}
 	/* FIXME: better variable names; generally make this nicer */
 	/* special case if old is parent of new active widget */
 	ltk_widget *tmp = common_parent;
 	while (tmp) {
 		if (tmp == old)
 			return;
 		tmp = tmp->parent;
 	}
 	if (old) {
 		old->state &= ~LTK_FOCUSED;
 		ltk_widget *cur = old;
 		while (cur) {
 			if (cur == common_parent)
 				break;
 			ltk_widget_state old_state = cur->state;
 			cur->state &= ~LTK_ACTIVE;
 			ltk_widget_change_state(cur, old_state);
 			cur = cur->parent;
 		}
 	}
 }
 
 void
 ltk_window_set_pressed_widget(ltk_window *window, ltk_widget *widget, int release) {
 	if (window->pressed_widget == widget)
 		return;
 	if (window->pressed_widget) {
 		ltk_widget_state old_state = window->pressed_widget->state;
 		window->pressed_widget->state &= ~LTK_PRESSED;
 		ltk_widget_change_state(window->pressed_widget, old_state);
 		ltk_window_set_active_widget(window, window->pressed_widget);
 		/* FIXME: this is a bit weird because the release handler for menuentry
 		   indirectly calls ltk_widget_hide, which messes with the pressed widget */
 		/* FIXME: isn't it redundant to check that state is pressed? */
 		if (release && window->pressed_widget->vtable->release && (old_state & LTK_PRESSED)) {
 			window->pressed_widget->vtable->release(window->pressed_widget);
 		}
 	}
 	window->pressed_widget = widget;
 	if (widget) {
 		if (widget->vtable->press)
 			widget->vtable->press(widget);
 		ltk_widget_state old_state = widget->state;
 		widget->state |= LTK_PRESSED;
 		ltk_widget_change_state(widget, old_state);
 	}
 }
 
 static void
 ltk_handle_event(ltk_window *window, ltk_event *event) {
 	size_t kbd_idx;
 	switch (event->type) {
 	case LTK_KEYPRESS_EVENT:
 		ltk_window_key_press_event(window, &event->key);
 		break;
 	case LTK_KEYRELEASE_EVENT:
 		ltk_window_key_release_event(window, &event->key);
 		break;
 	case LTK_BUTTONPRESS_EVENT:
 	case LTK_2BUTTONPRESS_EVENT:
 	case LTK_3BUTTONPRESS_EVENT:
 		ltk_window_mouse_press_event(window, &event->button);
 		break;
 	case LTK_SCROLL_EVENT:
 		ltk_window_mouse_scroll_event(window, &event->scroll);
 		break;
 	case LTK_BUTTONRELEASE_EVENT:
 	case LTK_2BUTTONRELEASE_EVENT:
 	case LTK_3BUTTONRELEASE_EVENT:
 		ltk_window_mouse_release_event(window, &event->button);
 		break;
 	case LTK_MOTION_EVENT:
 		ltk_window_motion_notify_event(window, &event->motion);
 		break;
 	case LTK_KEYBOARDCHANGE_EVENT:
 		/* FIXME: emit event */
 		if (ltk_config_get_language_index(event->keyboard.new_kbd, &kbd_idx))
 			ltk_warn("No language mapping for language \"%s\".\n", event->keyboard.new_kbd);
 		else
 			window->cur_kbd = kbd_idx;
 		break;
 	default:
 		if (window->other_event)
 			window->other_event(window, event);
 	}
 }
 
 /* Push a token onto `token_list`, resizing the buffer if necessary.
    Returns -1 on error, 0 otherwise.
    Note: The token is not copied, it is only added directly. */
 static int
 push_token(struct token_list *tl, char *token) {
 	int new_size;
 	if (tl->num_tokens >= tl->num_alloc) {
 		new_size = (tl->num_alloc * 2) > (tl->num_tokens + 1) ?
 			   (tl->num_alloc * 2) : (tl->num_tokens + 1);
 		ltk_cmd_token *new = ltk_reallocarray(tl->tokens, new_size, sizeof(ltk_cmd_token));
 		if (!new) return -1;
 		tl->tokens = new;
 		tl->num_alloc = new_size;
 	}
 	tl->tokens[tl->num_tokens].text = token;
 	tl->tokens[tl->num_tokens].len = 0;
 	tl->tokens[tl->num_tokens++].contains_nul = 0;
 
 	return 0;
 }
 
 /* Add a new client to the socket list and return the index in `sockets`.
    Returns -1 if there is no space for a new client. */
 static int
 add_client(int fd) {
 	for (int i = 0; i < MAX_SOCK_CONNS; i++) {
 		if (sockets[i].fd == -1) {
 			sockets[i].fd = fd;
 			sockets[i].event_mask = ~0; /* FIXME */
 			sockets[i].read_len = 0;
 			sockets[i].write_len = 0;
 			sockets[i].write_cur = 0;
 			sockets[i].offset = 0;
 			sockets[i].in_str = 0;
 			sockets[i].read_cur = 0;
 			sockets[i].bs = 0;
 			sockets[i].tokens.num_tokens = 0;
 			sockets[i].last_seq = 0;
 			return i;
 		}
 	}
 
 	return -1;
 }
 
 /* largely copied from APUE */
 /* Listen on the socket at `sock_path`.
    Returns the file descriptor of the opened socket on success.
    Returns -1 if `sock_path` is too long
            -2 if the socket could not be created
            -3 if the socket could not be bound to the path
            -4 if the socket could not be listened on */
 static int
 listen_sock(const char *sock_path) {
 	int fd, len, err, rval;
 	struct sockaddr_un un;
 
 	if (strlen(sock_path) >= sizeof(un.sun_path)) {
 		errno = ENAMETOOLONG;
 		return -1;
 	}
 
 	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
 		return -2;
 
 	unlink(sock_path);
 
 	memset(&un, 0, sizeof(un));
 	un.sun_family = AF_UNIX;
 	strcpy(un.sun_path, sock_path);
 	len = offsetof(struct sockaddr_un, sun_path) + strlen(sock_path);
 	if (bind(fd, (struct sockaddr *)&un, len) < 0) {
 		rval = -3;
 		goto errout;
 	}
 
 	if (listen(fd, 10) < 0) {
 		rval = -4;
 		goto errout;
 	}
 
 	return fd;
 
 errout:
 	err = errno;
 	close(fd);
 	errno = err;
 	return rval;
 }
 
 /* Accept a socket connection on the listening socket `listenfd`.
    Returns the file descriptor of the accepted client on success.
    Returns -1 if there was an error. */
 static int
 accept_sock(int listenfd) {
 	int clifd;
 	socklen_t len;
 	struct sockaddr_un un;
 
 	len = sizeof(un);
 	if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0) {
 		return -1;
 	}
 	if (set_nonblock(clifd)) {
 		/* FIXME: what could even be done if close fails? */
 		close(clifd);
 		return -1;
 	}
 
 	return clifd;
 }
 
 /* Read up to READ_BLK_SIZE bytes from the socket `sock`.
    Returns -1 if an error occurred, 0 if the connection was closed, 1 otherwise.
    Note: Returning 1 on success is weird, but it could also be confusing to
    return 0 on success when `read` returns that to mean that the connection
    was closed. */
 static int
 read_sock(struct ltk_sock_info *sock) {
 	int nread;
 	char *old = sock->read;
 	ltk_grow_string(&sock->read, &sock->read_alloc, sock->read_len + READ_BLK_SIZE);
 	/* move tokens to new addresses - this was added as an
 	   afterthought and really needs to be cleaned up */
 	if (sock->read != old) {
 		for (int i = 0; i < sock->tokens.num_tokens; i++) {
 			sock->tokens.tokens[i].text = sock->read + (sock->tokens.tokens[i].text - old);
 		}
 	}
 	nread = read(sock->fd, sock->read + sock->read_len, READ_BLK_SIZE);
 	if (nread == -1 || nread == 0)
 		return nread;
 	sock->read_len += nread;
 
 	return 1;
 }
 
 /* Write up to WRITE_BLK_SIZE bytes to the socket.
    Returns -1 on error, 0 otherwise. */
 static int
 write_sock(struct ltk_sock_info *sock) {
 	if (sock->write_len == sock->write_cur)
 		return 0;
 	int write_len = WRITE_BLK_SIZE > sock->write_len - sock->write_cur ?
 			sock->write_len - sock->write_cur : WRITE_BLK_SIZE;
 	int nwritten = write(sock->fd, sock->to_write + sock->write_cur, write_len);
 	if (nwritten == -1)
 		return nwritten;
 	sock->write_cur += nwritten;
 
 	/* check if any sockets have text to write */
 	if (sock->write_cur == sock->write_len) {
 		int found = 0;
 		for (int i = 0; i < maxsocket; i++) {
 			if (sockets[i].fd != -1 &&
 			    sockets[i].write_cur != sockets[i].write_len) {
 				found = 1;
 				break;
 			}
 		}
 		if (!found)
 			sock_write_available = 0;
 	}
 
 	return 0;
 }
 
 static void
 move_write_pos(struct ltk_sock_info *sock) {
 	/* FIXME: also resize if too large */
 	if (sock->write_cur > 0) {
 		memmove(sock->to_write, sock->to_write + sock->write_cur,
 		        sock->write_len - sock->write_cur);
 		sock->write_len -= sock->write_cur;
 		sock->write_cur = 0;
 	}
 }
 
 /* Queue `str` to be written to the socket. If len is < 0, it is set to `strlen(str)`.
    Returns -1 on error, 0 otherwise.
    Note: The string must include all '\n', etc. as defined in the protocol. This
    function just adds the given string verbatim. */
 int
 ltk_queue_sock_write(int client, const char *str, int len) {
 	if (client < 0 || client >= MAX_SOCK_CONNS || sockets[client].fd == -1)
 		return 1;
 	/* this is always large enough to hold a uint32_t and " \0" */
 	char num[12];
 	struct ltk_sock_info *sock = &sockets[client];
 	move_write_pos(sock);
 	if (len < 0)
 		len = strlen(str);
 
 	int numlen = snprintf(num, sizeof(num), "%"PRIu32" ", sock->last_seq);
 	if (numlen < 0 || (unsigned)numlen >= sizeof(num))
 		ltk_fatal("There's a bug in the universe.\n");
 	if (sock->write_alloc - sock->write_len < len + numlen)
 		ltk_grow_string(&sock->to_write, &sock->write_alloc, sock->write_len + len + numlen);
 
 	(void)strncpy(sock->to_write + sock->write_len, num, numlen);
 	(void)strncpy(sock->to_write + sock->write_len + numlen, str, len);
 	sock->write_len += len + numlen;
 
 	sock_write_available = 1;
 
 	return 0;
 }
 
 int
 ltk_queue_sock_write_fmt(int client, const char *fmt, ...) {
 	if (client < 0 || client >= MAX_SOCK_CONNS || sockets[client].fd == -1)
 		return 1;
 	struct ltk_sock_info *sock = &sockets[client];
 	/* just to print the sequence number */
 	ltk_queue_sock_write(client, "", 0);
 	va_list args;
 	va_start(args, fmt);
 	int len = vsnprintf(sock->to_write + sock->write_len, sock->write_alloc - sock->write_len, fmt, args);
 	if (len < 0) {
 		ltk_fatal("Unable to print formatted text to socket.\n");
 	} else if (len >= sock->write_alloc - sock->write_len) {
 		va_end(args);
 		va_start(args, fmt);
 		/* snprintf always writes '\0', even though we don't actually need it here */
 		ltk_grow_string(&sock->to_write, &sock->write_alloc, sock->write_len + len + 1);
 		vsnprintf(sock->to_write + sock->write_len, sock->write_alloc - sock->write_len, fmt, args);
 	}
 	va_end(args);
 	sock->write_len += len;
 	sock_write_available = 1;
 
 	return 0;
 }
 
 /* Tokenize the current read buffer in `sock`.
    Returns 0 immediately if the end of a command was encountered, 1 otherwise. */
 static int
 tokenize_command(struct ltk_sock_info *sock) {
 	for (; sock->read_cur < sock->read_len; sock->read_cur++) {
 		/* FIXME: strip extra whitespace? Or maybe just have a "hard" protocol where it always has to be one space. */
 		if (!sock->in_token) {
 			push_token(&sock->tokens, sock->read + sock->read_cur - sock->offset);
 			sock->in_token = 1;
 		}
 		if (sock->read[sock->read_cur] == '\\') {
 			sock->bs++;
 			if (sock->bs / 2)
 				sock->offset++;
 			else
 				sock->tokens.tokens[sock->tokens.num_tokens - 1].len++;
 			sock->bs %= 2;
 			sock->read[sock->read_cur-sock->offset] = '\\';
 		} else if (sock->read[sock->read_cur] == '\n' && !sock->in_str) {
 			sock->read[sock->read_cur-sock->offset] = '\0';
 			sock->read_cur++;
 			sock->offset = 0;
 			sock->in_token = 0;
 			sock->bs = 0;
 			return 0;
 		} else if (sock->read[sock->read_cur] == '"') {
 			sock->offset++;
 			if (sock->bs) {
 				sock->read[sock->read_cur-sock->offset] = '"';
 				sock->bs = 0;
 			} else {
 				sock->in_str = !sock->in_str;
 			}
 		} else if (sock->read[sock->read_cur] == ' ' && !sock->in_str) {
 			sock->read[sock->read_cur-sock->offset] = '\0';
 			sock->in_token = !sock->in_token;
 			sock->bs = 0;
 		} else {
 			sock->read[sock->read_cur-sock->offset] = sock->read[sock->read_cur];
 			/* FIXME: assert that num_tokens > 0 */
 			sock->tokens.tokens[sock->tokens.num_tokens - 1].len++;
 			if (sock->read[sock->read_cur] == '\0')
 				sock->tokens.tokens[sock->tokens.num_tokens - 1].contains_nul = 1;
 			sock->bs = 0;
 		}
 	}
 
 	return 1;
 }
 
 /* FIXME: currently no type-checking when setting specific widget mask */
 /* FIXME: this is really ugly and inefficient right now - it will be replaced with something
    more generic at some point (or maybe just with a binary protocol?) */
 static int
 handle_mask_command(int client, ltk_cmd_token *tokens, size_t num_tokens, ltk_error *err) {
 	if (num_tokens != 4 && num_tokens != 5) {
 		err->type = ERR_INVALID_NUMBER_OF_ARGUMENTS;
 		err->arg = -1;
 		return 1;
 	}
 	/* FIXME: make this nicer */
 	/* -> use generic cmd handling like the widgets */
 	if (tokens[1].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 1;
 		return 1;
 	} else if (tokens[2].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 2;
 		return 1;
 	} else if (tokens[3].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 3;
 		return 1;
 	} else if (num_tokens == 5 && tokens[4].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 4;
 		return 1;
 	}
 	uint32_t mask = 0;
 	int lock = 0;
 	int special = 0;
 	ltk_widget *widget = ltk_get_widget(tokens[1].text, LTK_WIDGET_ANY, err);
 	if (!widget) {
 		err->arg = 1;
 		return 1;
 	}
 	if (!strcmp(tokens[2].text, "widget")) {
 		if (!strcmp(tokens[3].text, "mousepress")) {
 			mask = LTK_PEVENTMASK_MOUSEPRESS;
 		} else if (!strcmp(tokens[3].text, "mouserelease")) {
 			mask = LTK_PEVENTMASK_MOUSERELEASE;
 		} else if (!strcmp(tokens[3].text, "mousemotion")) {
 			mask = LTK_PEVENTMASK_MOUSEMOTION;
 		} else if (!strcmp(tokens[3].text, "configure")) {
 			mask = LTK_PEVENTMASK_CONFIGURE;
 		} else if (!strcmp(tokens[3].text, "statechange")) {
 			mask = LTK_PEVENTMASK_STATECHANGE;
 		} else if (!strcmp(tokens[3].text, "none")) {
 			mask = LTK_PEVENTMASK_NONE;
 		} else {
 			err->type = ERR_INVALID_ARGUMENT;
 			err->arg = 3;
 			return 1;
 		}
 	} else if (!strcmp(tokens[2].text, "menuentry")) {
 		if (!strcmp(tokens[3].text, "press")) {
 			mask = LTK_PWEVENTMASK_MENUENTRY_PRESS;
 		} else if (!strcmp(tokens[3].text, "none")) {
 			mask = LTK_PWEVENTMASK_MENUENTRY_NONE;
 		} else {
 			err->type = ERR_INVALID_ARGUMENT;
 			err->arg = 3;
 			return 1;
 		}
 		special = 1;
 	} else if (!strcmp(tokens[2].text, "button")) {
 		if (!strcmp(tokens[3].text, "press")) {
 			mask = LTK_PWEVENTMASK_BUTTON_PRESS;
 		} else if (!strcmp(tokens[3].text, "none")) {
 			mask = LTK_PWEVENTMASK_BUTTON_NONE;
 		} else {
 			err->type = ERR_INVALID_ARGUMENT;
 			err->arg = 3;
 			return 1;
 		}
 		special = 1;
 	} else {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 2;
 		return 1;
 	}
 	if (num_tokens == 5) {
 		if (!strcmp(tokens[4].text, "lock")) {
 			lock = 1;
 		} else {
 			err->type = ERR_INVALID_ARGUMENT;
 			err->arg = 4;
 			return 1;
 		}
 	}
 
 	if (!strcmp(tokens[0].text, "mask-add")) {
 		if (lock) {
 			if (special)
 				ltk_widget_add_to_event_lwmask(widget, client, mask);
 			else
 				ltk_widget_add_to_event_lmask(widget, client, mask);
 		} else {
 			if (special)
 				ltk_widget_add_to_event_wmask(widget, client, mask);
 			else
 				ltk_widget_add_to_event_mask(widget, client, mask);
 		}
 	} else if (!strcmp(tokens[0].text, "mask-set")) {
 		if (lock) {
 			if (special)
 				ltk_widget_set_event_lwmask(widget, client, mask);
 			else
 				ltk_widget_set_event_lmask(widget, client, mask);
 		} else {
 			if (special)
 				ltk_widget_set_event_wmask(widget, client, mask);
 			else
 				ltk_widget_set_event_mask(widget, client, mask);
 		}
 	} else if (!strcmp(tokens[0].text, "mask-remove")) {
 		if (lock) {
 			if (special)
 				ltk_widget_remove_from_event_lwmask(widget, client, mask);
 			else
 				ltk_widget_remove_from_event_lmask(widget, client, mask);
 		} else {
 			if (special)
 				ltk_widget_remove_from_event_wmask(widget, client, mask);
 			else
 				ltk_widget_remove_from_event_mask(widget, client, mask);
 		}
 	} else {
 		err->type = ERR_INVALID_COMMAND;
 		err->arg = 0;
 		return 1;
 	}
 	return 0;
 }
 
 /* Process the commands as they are read from the socket. */
 /* Returns 1 if command was 'event-unlock true',
    -1 if command was 'event-unlock false', 0 otherwise. */
 static int
 process_commands(ltk_window *window, int client) {
 	if (client < 0 || client >= MAX_SOCK_CONNS || sockets[client].fd == -1)
 		return 0;
 	struct ltk_sock_info *sock = &sockets[client];
 	ltk_cmd_token *tokens;
 	int num_tokens;
 	ltk_error errdetail = {ERR_NONE, -1};
 	int err;
 	int retval = 0;
 	int last = 0;
 	uint32_t seq;
 	const char *errstr;
 	int contains_nul = 0;
 	while (!tokenize_command(sock)) {
 		contains_nul = 0;
 		err = 0;
 		tokens = sock->tokens.tokens;
 		num_tokens = sock->tokens.num_tokens;
 		if (num_tokens < 2) {
 			errdetail.type = ERR_INVALID_COMMAND;
 			errdetail.arg = -1;
 			err = 1;
 		} else {
 			contains_nul = tokens[0].contains_nul;
 			seq = (uint32_t)ltk_strtonum(tokens[0].text, 0, UINT32_MAX, &errstr);
 			tokens++;
 			num_tokens--;
 			if (errstr || contains_nul) {
 				errdetail.type = ERR_INVALID_SEQNUM;
 				errdetail.arg = -1;
 				err = 1;
 				seq = sock->last_seq;
 			} else if (tokens[0].contains_nul) {
 				errdetail.type = ERR_INVALID_ARGUMENT;
 				errdetail.arg = 0;
 				err = 1;
 				seq = sock->last_seq;
 			} else if (strcmp(tokens[0].text, "set-root-widget") == 0) {
 				err = ltk_set_root_widget_cmd(window, tokens, num_tokens, &errdetail);
 			} else if (strcmp(tokens[0].text, "quit") == 0) {
 				ltk_quit(window);
 				last = 1;
 			} else if (strcmp(tokens[0].text, "destroy") == 0) {
 				err = ltk_widget_destroy_cmd(window, tokens, num_tokens, &errdetail);
 			} else if (strncmp(tokens[0].text, "mask", 4) == 0) {
 				err = handle_mask_command(client, tokens, num_tokens, &errdetail);
 			} else if (strcmp(tokens[0].text, "event-unlock") == 0) {
 				if (num_tokens != 2) {
 					errdetail.type = ERR_INVALID_NUMBER_OF_ARGUMENTS;
 					errdetail.arg = -1;
 					err = 1;
 				} else if (!tokens[1].contains_nul && strcmp(tokens[1].text, "true") == 0) {
 					retval = 1;
 				} else if (!tokens[1].contains_nul && strcmp(tokens[1].text, "false") == 0) {
 					retval = -1;
 				} else {
 					err = 1;
 					errdetail.type = ERR_INVALID_ARGUMENT;
 					errdetail.arg = 1;
 				}
 				last = 1;
 			} else {
 				int found = 0;
 				for (size_t i = 0; i < LENGTH(widget_funcs); i++) {
 					if (widget_funcs[i].cmd && !strcmp(tokens[0].text, widget_funcs[i].name)) {
 						err = widget_funcs[i].cmd(window, tokens, num_tokens, &errdetail);
 						found = 1;
 					}
 				}
 				if (!found) {
 					errdetail.type = ERR_INVALID_COMMAND;
 					errdetail.arg = -1;
 					err = 1;
 				}
 			}
 			sock->tokens.num_tokens = 0;
 			sock->last_seq = seq;
 		}
 		if (err) {
 			const char *errmsg = errtype_to_string(errdetail.type);
 			if (ltk_queue_sock_write_fmt(client, "err %d %d \"%s\"\n", errdetail.type, errdetail.arg, errmsg))
 				ltk_fatal("Unable to queue socket write.\n");
 		} else {
 			if (ltk_queue_sock_write(client, "res ok\n", -1)) {
 				ltk_fatal("Unable to queue socket write.\n");
 			}
 		}
 		if (last)
 			break;
 	}
 	if (sock->tokens.num_tokens > 0 && sock->tokens.tokens[0].text != sock->read) {
 		memmove(sock->read, sock->tokens.tokens[0].text, sock->read + sock->read_len - sock->tokens.tokens[0].text);
 		ptrdiff_t offset = sock->tokens.tokens[0].text - sock->read;
 		/* Hmm, seems a bit ugly... */
 		for (int i = 0; i < sock->tokens.num_tokens; i++) {
 			sock->tokens.tokens[i].text -= offset;
 		}
 		sock->read_len -= offset;
 		sock->read_cur -= offset;
 	} else if (sock->tokens.num_tokens == 0) {
 		sock->read_len = 0;
 		sock->read_cur = 0;
 	}
 	return retval;
 }