ltk

ltk.c (22755B)

---

 /*
  * Copyright (c) 2016-2026 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 <locale.h>
 #include <pwd.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 
 #include <sys/wait.h>
 
 #include "ltk.h"
 #include "array.h"
 #include "button.h"
 #include "config.h"
 #include "entry.h"
 #include "event.h"
 #include "eventdefs.h"
 #include "graphics.h"
 #include "image.h"
 #include "label.h"
 #include "macros.h"
 #include "memory.h"
 #include "menu.h"
 #include "rect.h"
 #include "scrollbar.h"
 #include "text.h"
 #include "util.h"
 #include "widget.h"
 #include "widget_internal.h"
 
 typedef struct {
 	ltk_widget_id caller;
 	char *infile;
 	char *outfile;
 	int pid;
 } ltk_cmdinfo;
 
 typedef struct {
 	void (*callback)(ltk_callback_arg data);
 	ltk_callback_arg data;
 	struct timespec repeat;
 	struct timespec remaining;
 	int id;
 } ltk_timer;
 
 LTK_ARRAY_INIT_DECL_STATIC(window, ltk_window *)
 LTK_ARRAY_INIT_IMPL_STATIC(window, ltk_window *)
 LTK_ARRAY_INIT_DECL_STATIC(rwindow, ltk_renderwindow *)
 LTK_ARRAY_INIT_IMPL_STATIC(rwindow, ltk_renderwindow *)
 LTK_ARRAY_INIT_DECL_STATIC(cmdinfo, ltk_cmdinfo)
 LTK_ARRAY_INIT_IMPL_STATIC(cmdinfo, ltk_cmdinfo)
 LTK_ARRAY_INIT_DECL_STATIC(widget, ltk_widget *)
 LTK_ARRAY_INIT_IMPL_STATIC(widget, ltk_widget *)
 LTK_ARRAY_INIT_DECL_STATIC(gen_num, ltk_widget_id_int_type)
 LTK_ARRAY_INIT_IMPL_STATIC(gen_num, ltk_widget_id_int_type)
 LTK_ARRAY_INIT_DECL_STATIC(timer, ltk_timer)
 LTK_ARRAY_INIT_IMPL_STATIC(timer, ltk_timer)
 
 static struct {
 	ltk_renderdata *renderdata;
 	ltk_text_context *text_context;
 	ltk_clipboard *clipboard;
 	/* FIXME: For the current event mechanism to work properly, the windows need to be stored
 	   in a separate array here in addition to the general widgets array that they are stored
 	   in anyways. Maybe fix this so they are only stored in one place? */
 	ltk_array(window) *windows;
 	ltk_array(rwindow) *rwindows;
 	/* PID of external command called e.g. by text widget to edit text.
 	   ON exit, cmd_caller->vtable->cmd_return is called with the text
 	   the external command wrote to a file. */
 	/*FIXME: this needs to be checked whenever a widget is destroyed!*/
 	/* -> actually, if widget ID system is implemented, this can just check if ID is still valid on command return
 	      -> although, that could cause weirdness in extreme edge cases when the generation number of the ID has
 		 wrapped around so there is actually a valid ID at that position - would at least need to check if cmd_return is actually valid for widget */
 	ltk_array(cmdinfo) *cmds;
 	ltk_array(timer) *timers;
 	/* widgets is an array of all widgets, with entries of deleted widgets being NULL until
 	   they are reused. cur_widget_clock_pos contains the index from which a search for an
 	   empty slot should start. If no empty slot is found and the size of the array is less
 	   than LTK_MAX_WIDGET_IDX, the array size is increased. In order to give an error when
 	   a widget that has been deleted is requested and the slot has already been filled with
 	   a new widget, each widget ID contains a generation number. gen_nums contains the
 	   current generation number for each slot, which is increased whenever a widget is added
 	   to the slot. A valid widget ID can never have a generation number of 0 (this is so
 	   there's a special widget ID that can be used to signal that the ID is invalid). */
 	ltk_array(widget) *widgets;
 	ltk_array(gen_num) *gen_nums;
 	ltk_widget_id_int_type cur_widget_clock_pos;
 	size_t cur_kbd;
 } shared_data = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, 0};
 
 static void ltk_handle_event(ltk_event *event);
 
 static short running = 1;
 
 typedef struct {
 	char *name;
 	void (*cleanup)(void);
 } ltk_widget_funcs;
 
 /* FIXME: I guess the names aren't needed anymore here, but who
    knows if I'll need them again sometime... */
 static ltk_widget_funcs widget_funcs[] = {
 	{
 		.name = "entry",
 		.cleanup = &ltk_entry_cleanup,
 	},
 	{
 		.name = "combobox",
 		.cleanup = &ltk_combobox_cleanup,
 	},
 	{
 		/* Handler for window theme. */
 		.name = "window",
 		.cleanup = &ltk_window_cleanup,
 	}
 };
 
 ltk_renderdata *
 ltk_get_renderer(void) {
 	/* FIXME: check if initialized? */
 	return shared_data.renderdata;
 }
 
 int
 ltk_init(void) {
 	/* FIXME: should ltk set this? probably not */
 	setlocale(LC_CTYPE, "");
 	char *ltk_dir = ltk_setup_directory("LTKDIR", ".ltk", 0);
 	if (!ltk_dir)
 		ltk_fatal_errno("Unable to setup ltk directory.\n");
 	shared_data.cur_kbd = 0;
 
 	shared_data.renderdata = ltk_renderer_create();
 	if (!shared_data.renderdata)
 		return 1; /* FIXME: clean up */
 
 	/* FIXME: search different directories for config */
 	/* FIXME: don't print error if config file doesn't exist */
 	char *config_path = ltk_strcat_useful(ltk_dir, "/ltk.cfg");
 	ltk_free0(ltk_dir);
 	char *errstr = NULL;
 	if (ltk_config_parsefile(shared_data.renderdata, config_path, &errstr)) {
 		if (errstr) {
 			ltk_warn("Unable to load config: %s\n", errstr);
 			ltk_free0(errstr);
 		}
 		if (ltk_config_load_default(shared_data.renderdata, &errstr)) {
 			/* FIXME: I guess errstr isn't freed here, but whatever */
 			/* FIXME: return error instead of dying */
 			ltk_fatal("Unable to load default config: %s\n", errstr);
 		}
 	}
 	ltk_free0(config_path);
 
 	ltk_events_init(shared_data.renderdata);
 	shared_data.text_context = ltk_text_context_create(shared_data.renderdata);
 	shared_data.clipboard = ltk_clipboard_create(shared_data.renderdata);
 	/* FIXME: configure cache size; check for overflow */
 	ltk_image_init(shared_data.renderdata, 1024 * 1024 * 4);
 	shared_data.windows = ltk_array_create(window, 1);
 	shared_data.rwindows = ltk_array_create(rwindow, 1);
 	shared_data.cmds = ltk_array_create(cmdinfo, 1);
 	shared_data.widgets = ltk_array_create(widget, 1);
 	shared_data.gen_nums = ltk_array_create(gen_num, 1);
 	shared_data.timers = ltk_array_create(timer, 1);
 	return 0; /* FIXME: or maybe 1? */
 }
 
 ltk_widget *
 ltk_get_widget_from_id(ltk_widget_id id) {
 	ltk_assert(id.gen > 0);
 	ltk_assert(id.idx < ltk_array_len(shared_data.widgets));
 	ltk_widget *widget = ltk_array_get(shared_data.widgets, id.idx);
 	ltk_assert(widget != NULL);
 	ltk_assert(widget->id.gen == id.gen);
 	return widget;
 }
 
 ltk_widget *
 ltk_get_widget_or_null_from_id(ltk_widget_id id) {
 	return id.gen == 0 ? NULL : ltk_get_widget_from_id(id);
 }
 
 ltk_widget *
 ltk_get_widget_or_null_from_id_nofail(ltk_widget_id id) {
 	if (id.gen == 0 || id.idx >= ltk_array_len(shared_data.widgets))
 		return NULL;
 	ltk_widget *widget = ltk_array_get(shared_data.widgets, id.idx);
 	if (!widget || widget->id.gen != id.gen)
 		return NULL;
 	return widget;
 }
 
 ltk_widget_id
 ltk_store_widget(ltk_widget *widget) {
 	for (size_t i = 0; i < ltk_array_len(shared_data.widgets); ++i) {
 		if (!ltk_array_get(shared_data.widgets, shared_data.cur_widget_clock_pos)) {
 			size_t idx = shared_data.cur_widget_clock_pos;
 			ltk_array_get(shared_data.widgets, idx) = widget;
 			ltk_array_get(shared_data.gen_nums, idx)++;
 			shared_data.cur_widget_clock_pos++;
 			shared_data.cur_widget_clock_pos %= ltk_array_len(shared_data.widgets);
 			return (ltk_widget_id){idx, ltk_array_get(shared_data.gen_nums, idx)};
 		}
 		shared_data.cur_widget_clock_pos++;
 		shared_data.cur_widget_clock_pos %= ltk_array_len(shared_data.widgets);
 	}
 	size_t idx = ltk_array_len(shared_data.widgets);
 	ltk_assert(idx <= LTK_MAX_WIDGET_IDX);
 	ltk_array_append(widget, shared_data.widgets, widget);
 	ltk_array_len_to_capacity(widget, shared_data.widgets, NULL);
 	if (ltk_array_len(shared_data.widgets) > (size_t)LTK_MAX_WIDGET_IDX + 1U)
 		ltk_array_resize(widget, shared_data.widgets, (size_t)LTK_MAX_WIDGET_IDX + 1U, NULL);
 	ltk_array_resize(gen_num, shared_data.gen_nums, ltk_array_len(shared_data.widgets), 0);
 	ltk_array_get(shared_data.gen_nums, idx) = 1;
 	shared_data.cur_widget_clock_pos = idx + 1;
 	shared_data.cur_widget_clock_pos %= ltk_array_len(shared_data.widgets);
 	return (ltk_widget_id){idx, 1};
 }
 
 void
 ltk_clear_widget_slot(ltk_widget_id id) {
 	ltk_assert(id.idx < ltk_array_len(shared_data.widgets));
 	ltk_array_get(shared_data.widgets, id.idx) = NULL;
 }
 
 static struct {
 	struct timespec last;
 	struct timespec lasttimer;
 } mainloop_data;
 
 void
 ltk_mainloop_init(void) {
 	clock_gettime(CLOCK_MONOTONIC, &mainloop_data.last);
 	mainloop_data.lasttimer = mainloop_data.last;
 
 	/* initialize keyboard mapping */
 	ltk_event event;
 	ltk_generate_keyboard_event(shared_data.renderdata, &event);
 	ltk_handle_event(&event);
 }
 
 /* FIXME: maybe split this up into multiple stages */
 void
 ltk_mainloop_step(int limit_framerate) {
 	ltk_event event;
 
 	/* 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 (would need separate parameter to turn that off when a
 	   different mainloop is used) */
 	struct timespec now, elapsed, sleep_time;
 	sleep_time.tv_sec = 0;
 
 	int pid = -1;
 	int wstatus = 0;
 	/* FIXME: kill all children on exit? */
 	/* -> at least unlink any files? */
 	if ((pid = waitpid(-1, &wstatus, WNOHANG)) > 0) {
 		ltk_cmdinfo *info;
 		/* FIXME: should commands be split into read/write and block write commands during external editing? */
 		for (size_t i = 0; i < ltk_array_len(shared_data.cmds); i++) {
 			info = &(ltk_array_get(shared_data.cmds, i));
 			if (info->pid == pid) {
 				ltk_widget *caller = ltk_get_widget_or_null_from_id_nofail(info->caller);
 				if (!caller) {
 					ltk_warn("Widget disappeared while text was being edited in external program\n");
 				/* FIXME: call overwritten cmd_return! */
 				} else if (caller->vtable->cmd_return) {
 					size_t file_len = 0;
 					char *errstr = NULL;
 					char *filename = info->outfile ? info->outfile : info->infile;
 					char *contents = ltk_read_file(filename, &file_len, &errstr);
 					if (!contents) {
 						ltk_warn("Unable to read file '%s' written by external command: %s\n", filename, errstr);
 					} else {
 						caller->vtable->cmd_return(caller, contents, file_len);
 						ltk_free0(contents);
 					}
 				}
 				/* FIXME: error checking */
 				unlink(info->infile);
 				ltk_free(info->infile);
 				if (info->outfile) {
 					unlink(info->outfile);
 					ltk_free(info->outfile);
 				}
 				ltk_array_delete(cmdinfo, shared_data.cmds, i, 1);
 				break;
 			}
 		}
 	}
 	while (!ltk_next_event(
 	    shared_data.renderdata,
 	    ltk_array_get_buf(shared_data.rwindows),
 	    ltk_array_len(shared_data.rwindows),
 	    shared_data.clipboard, shared_data.cur_kbd, &event)) {
 		ltk_handle_event(&event);
 	}
 
 	clock_gettime(CLOCK_MONOTONIC, &now);
 	ltk_timespecsub(&now, &mainloop_data.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 < ltk_array_len(shared_data.timers)) {
 		ltk_timer *cur_timer = &ltk_array_get(shared_data.timers, i);
 		ltk_timespecsub(&cur_timer->remaining, &elapsed, &cur_timer->remaining);
 		if (cur_timer->remaining.tv_sec < 0 ||
 		    (cur_timer->remaining.tv_sec == 0 && cur_timer->remaining.tv_nsec == 0)) {
 			cur_timer->callback(cur_timer->data);
 			if (cur_timer->repeat.tv_sec == 0 && cur_timer->repeat.tv_nsec == 0) {
 				/* remove timer because it has no repeat */
 				ltk_array_delete(timer, shared_data.timers, i, 1);
 			} else {
 				ltk_timespecadd(&cur_timer->remaining, &cur_timer->repeat, &cur_timer->remaining);
 				i++;
 			}
 		} else {
 			i++;
 		}
 	}
 	mainloop_data.lasttimer = now;
 
 	for (size_t i = 0; i < ltk_array_len(shared_data.windows); i++) {
 		ltk_window *window = ltk_array_get(shared_data.windows, i);
 		if (window->dirty_rect.w != 0 && window->dirty_rect.h != 0) {
 			ltk_widget_draw(LTK_CAST_WIDGET(window), NULL, 0, 0, (ltk_rect){0, 0, 0, 0});
 		}
 	}
 
 	if (limit_framerate) {
 		clock_gettime(CLOCK_MONOTONIC, &now);
 		ltk_timespecsub(&now, &mainloop_data.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);
 		}
 		mainloop_data.last = now;
 	}
 }
 
 void
 ltk_mainloop_quit(void) {
 	/* FIXME: maybe prevent other events from running? */
 	running = 0;
 }
 
 void
 ltk_mainloop_restartable(void) {
 	ltk_mainloop_init();
 	while (running) {
 		ltk_mainloop_step(1);
 	}
 }
 
 void
 ltk_mainloop(void) {
 	ltk_mainloop_restartable();
 	ltk_deinit();
 }
 
 void
 ltk_deinit(void) {
 	/* if renderdata is NULL, the other initialization can't have happened either */
 	if (running || !shared_data.renderdata)
 		return;
 	if (shared_data.cmds) {
 		for (size_t i = 0; i < ltk_array_len(shared_data.cmds); i++) {
 			/* FIXME: maybe kill child processes? */
 			ltk_free((ltk_array_get(shared_data.cmds, i)).infile);
 			if (ltk_array_get(shared_data.cmds, i).outfile)
 				ltk_free((ltk_array_get(shared_data.cmds, i)).outfile);
 		}
 		ltk_array_destroy(cmdinfo, shared_data.cmds);
 	}
 	shared_data.cmds = NULL;
 	/* FIXME: maybe special destroy function for cleanup at end that doesn't emit signals, etc. */
 	for (size_t i = 0; i < ltk_array_len(shared_data.windows); i++) {
 		ltk_window *window = ltk_array_get(shared_data.windows, i);
 		ltk_widget_destroy(LTK_CAST_WIDGET(window), 1);
 	}
 	ltk_array_destroy(window, shared_data.windows);
 	shared_data.windows = NULL;
 	ltk_array_destroy(rwindow, shared_data.rwindows);
 	shared_data.rwindows = NULL;
 	for (size_t i = 0; i < ltk_array_len(shared_data.widgets); i++) {
 		/* FIXME: not sure about this warning - the idea is to do a deep destroy of the
 		   windows above, then warn if there are any widgets that were not destroyed
 		   (i.e. not referenced in a window), but I'm not sure how useful that is */
 		ltk_widget *widget = ltk_array_get(shared_data.widgets, i);
 		if (widget) {
 			ltk_warn("Widget not contained within window still stored at index %zu in widget array on exit.\n", i);
 			ltk_widget_destroy(widget, 0);
 		}
 	}
 	ltk_array_destroy(widget, shared_data.widgets);
 	shared_data.widgets = NULL;
 	ltk_array_destroy(gen_num, shared_data.gen_nums);
 	shared_data.gen_nums = NULL;
 	ltk_array_destroy(timer, shared_data.timers);
 	shared_data.timers = NULL;
 	for (size_t i = 0; i < LENGTH(widget_funcs); i++) {
 		if (widget_funcs[i].cleanup)
 			widget_funcs[i].cleanup();
 	}
 	ltk_config_cleanup(shared_data.renderdata);
 	if (shared_data.text_context)
 		ltk_text_context_destroy(shared_data.text_context);
 	shared_data.text_context = NULL;
 	if (shared_data.clipboard)
 		ltk_clipboard_destroy(shared_data.clipboard);
 	shared_data.clipboard = NULL;
 	ltk_events_cleanup();
 	ltk_renderer_destroy(shared_data.renderdata);
 	shared_data.renderdata = NULL;
 }
 
 /* FIXME: check everywhere if initialized already */
 ltk_widget_id
 ltk_window_create(const char *title, int x, int y, unsigned int w, unsigned int h) {
 	/* FIXME: more asserts, or maybe global "initialized" flag */
 	ltk_assert(shared_data.renderdata != NULL);
 	ltk_assert(shared_data.windows != NULL);
 	ltk_assert(shared_data.rwindows != NULL);
 	ltk_window *window = ltk_window_create_intern(shared_data.renderdata, title, x, y, w, h);
 	ltk_array_append(window, shared_data.windows, window);
 	ltk_array_append(rwindow, shared_data.rwindows, window->renderwindow);
 	return LTK_CAST_WIDGET(window)->id;
 }
 
 void
 ltk_window_destroy(ltk_widget *self, int shallow) {
 	/* FIXME: would it make sense to do something with 'shallow' here? */
 	(void)shallow;
 	ltk_window *window = LTK_CAST_WINDOW(self);
 	for (size_t i = 0; i < ltk_array_len(shared_data.windows); i++) {
 		if (ltk_array_get(shared_data.windows, i) == window) {
 			ltk_array_delete(window, shared_data.windows, i, 1);
 			ltk_array_delete(rwindow, shared_data.rwindows, i, 1);
 			break;
 		}
 	}
 	ltk_window_destroy_intern(window);
 }
 
 ltk_clipboard *
 ltk_get_clipboard(void) {
 	/* FIXME: what to do when not initialized? */
 	return shared_data.clipboard;
 }
 
 /* FIXME: optimize timer handling - maybe also a sort of priority queue */
 void
 ltk_unregister_timer(int timer_id) {
 	for (size_t i = 0; i < ltk_array_len(shared_data.timers); i++) {
 		if (ltk_array_get(shared_data.timers, i).id == timer_id) {
 			ltk_array_delete(timer, shared_data.timers, i, 1);
 			return;
 		}
 	}
 }
 
 /* repeat <= 0 means no repeat, first <= 0 means run as soon as possible */
 int
 ltk_register_timer(long first, long repeat, void (*callback)(ltk_callback_arg data), ltk_callback_arg data) {
 	if (first < 0)
 		first = 0;
 	if (repeat < 0)
 		repeat = 0;
 	/* FIXME: better finding of id */
 	/* FIXME: maybe store sorted by id */
 	int id = 0;
 	for (size_t i = 0; i < ltk_array_len(shared_data.timers); i++) {
 		if (ltk_array_get(shared_data.timers, i).id >= id)
 			id = ltk_array_get(shared_data.timers, i).id + 1;
 	}
 	ltk_timer t;
 	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;
 	ltk_array_append(timer, shared_data.timers, t);
 	return id;
 }
 
 LTK_ARRAY_INIT_DECL_STATIC(str, char *)
 LTK_ARRAY_INIT_IMPL_STATIC(str, char *)
 
 static void
 str_free_helper(char *elem) {
 	ltk_free(elem);
 }
 
 int
 ltk_call_cmd(ltk_widget_id callerid, ltk_array(cmd) *cmd, const char *text, size_t textlen) {
 	/* FIXME: maybe support stdin/stdout without temporary files by just piping directly */
 	/* FIXME: support environment variable $TMPDIR */
 	ltk_cmdinfo info = {
 		.caller = LTK_WIDGET_ID_NONE, .infile = NULL, .outfile = NULL, .pid = -1
 	};
 	ltk_array(str) *cmdstr = ltk_array_create(str, 4);
 	txtbuf *tmpbuf = txtbuf_new();
 	int needs_stdin = 1;
 	int needs_stdout = 1;
 
 	int infd = -1, outfd = -1;
 
 	info.infile = ltk_strdup("/tmp/ltk.XXXXXX");
 	infd = mkstemp(info.infile);
 	if (infd == -1) {
 		ltk_warn_errno("Unable to create temporary input file while trying to run command.");
 		ltk_free(info.infile);
 		info.infile = NULL; /* so it isn't unlinked below */
 		goto error;
 	}
 	/* FIXME: give file descriptor directly to modified version of ltk_write_file */
 	char *errstr = NULL;
 	if (ltk_write_file(info.infile, text, textlen, &errstr)) {
 		ltk_warn("Unable to write to temporary input file '%s' while trying to run command.", info.infile, errstr);
 		goto error;
 	}
 
 	for (size_t i = 0; i < ltk_array_len(cmd); i++) {
 		ltk_array(cmdpiece) *pa = ltk_array_get(cmd, i);
 		for (size_t j = 0; j < ltk_array_len(pa); j++) {
 			struct ltk_cmd_piece p = ltk_array_get(pa, j);
 			switch (p.type) {
 			case LTK_CMD_TEXT:
 				txtbuf_append(tmpbuf, p.text);
 				break;
 			case LTK_CMD_INOUT_FILE:
 				needs_stdout = 0;
 				/* fall through */
 			case LTK_CMD_INPUT_FILE:
 				needs_stdin = 0;
 				txtbuf_append(tmpbuf, info.infile);
 				break;
 			case LTK_CMD_OUTPUT_FILE:
 				needs_stdout = 0;
 				if (!info.outfile) {
 					info.outfile = ltk_strdup("/tmp/ltk.XXXXXX");
 					outfd = mkstemp(info.outfile);
 					if (outfd == -1) {
 						ltk_warn_errno("Unable to create temporary output file while trying to run command.");
 						ltk_free(info.outfile);
 						info.outfile = NULL; /* so it isn't unlinked below */
 						goto error;
 					}
 				}
 				txtbuf_append(tmpbuf, info.outfile);
 				break;
 			default:
 				ltk_warn("Invalid command piece type. This should not happen.");
 				goto error;
 			}
 		}
 		ltk_array_append(str, cmdstr, txtbuf_get_textcopy(tmpbuf));
 		txtbuf_clear(tmpbuf);
 	}
 	/* if no output file was specified, we still need to create it for stdout */
 	if (needs_stdout) {
 		info.outfile = ltk_strdup("/tmp/ltk.XXXXXX");
 		outfd = mkstemp(info.outfile);
 		if (outfd == -1) {
 			ltk_warn_errno("Unable to create temporary output file while trying to run command.");
 			ltk_free(info.outfile);
 			info.outfile = NULL; /* so it isn't unlinked below */
 			goto error;
 		}
 	}
 	ltk_array_append(str, cmdstr, NULL); /* necessary for execvp */
 	txtbuf_destroy(tmpbuf);
 	tmpbuf = NULL;
 
 	int fret = -1;
 	if ((fret = fork()) < 0) {
 		ltk_warn("Unable to fork\n");
 		goto error;
 	} else if (fret == 0) {
 		if (needs_stdin) {
 			if (dup2(infd, fileno(stdin)) == -1)
 				ltk_fatal("Unable to set up stdin in child process.");
 		}
 		if (needs_stdout) {
 			int fd = outfd == -1 ? infd : outfd;
 			if (dup2(fd, fileno(stdout)) == -1)
 				ltk_fatal("Unable to set up stdout in child process.");
 		}
 		if (execvp(cmdstr->buf[0], cmdstr->buf) == -1)
 			ltk_fatal("Unable to exec external command.");
 	}
 	ltk_array_destroy_deep(str, cmdstr, &str_free_helper);
 
 	info.pid = fret;
 	info.caller = callerid;
 	ltk_array_append(cmdinfo, shared_data.cmds, info);
 
 	if (infd != -1)
 		close(infd); /* FIXME: error checking also on close */
 	if (outfd != -1)
 		close(outfd);
 	return 0;
 error:
 	if (infd != -1)
 		close(infd); /* FIXME: error checking also on close and unlink */
 	if (outfd != -1)
 		close(outfd);
 	if (tmpbuf)
 		txtbuf_destroy(tmpbuf);
 	if (info.infile) {
 		unlink(info.infile);
 		ltk_free(info.infile);
 	}
 	if (info.outfile) {
 		unlink(info.outfile);
 		ltk_free(info.outfile);
 	}
 	ltk_array_destroy_deep(str, cmdstr, &str_free_helper);
 	return 1;
 }
 
 static void
 ltk_handle_event(ltk_event *event) {
 	size_t kbd_idx;
 	if (event->type == 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
 			shared_data.cur_kbd = kbd_idx;
 	} else {
 		if (event->any.window_id < ltk_array_len(shared_data.windows)) {
 			ltk_window *window = ltk_array_get(shared_data.windows, event->any.window_id);
 			ltk_window_handle_event(LTK_CAST_WIDGET(window)->id, event);
 		} else {
 			ltk_warn("Invalid window ID %zu in event.", event->any.window_id);
 		}
 	}
 }
 
 ltk_text_line *
 ltk_text_line_create_default(const char *font, int font_size, char *text, int take_over_text, int width) {
 	return ltk_text_line_create(shared_data.text_context, font, font_size, text, take_over_text, width);
 }
 
 ltk_text_line *
 ltk_text_line_create_const_text_default(const char *font, int font_size, const char *text, int width) {
 	return ltk_text_line_create_const_text(shared_data.text_context, font, font_size, text, width);
 }