poe

poe.c (59311B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2021-2024  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #define TB_OPT_V1_COMPAT
 #define TB_IMPL
 
 #define COPYRIGHT                                                             \
 	("  This program is licensed under the terms of GNU GPL v3"           \
 	 " or (at your option)\n"                                             \
 	 "  any later version. Copyright (C) 2021-2024  Strahinya Radich.\n"  \
 	 "  See the file LICENSE for exact copyright and license "            \
 	 "details.\n"                                                         \
 	 "  File termbox.h is based on termbox2 TUI library, (c) 2021"        \
 	 " termbox developers,\n"                                             \
 	 "  which is released under the terms of Expat license, see the file" \
 	 "  LICENSE.termbox.\n")
 #define POE_C_GLOBALS
 
 #include "version.h"
 #include "util.h"
 #include "po.h"
 #include "draw.h"
 #include "config.h"
 
 extern const char* backup_suffix;
 extern const char* errors[];
 extern const char* prompt_dirty;
 extern const char* prompt_cancel_dirty;
 extern const char* prompt_overwrite;
 
 void cancel_callback(struct DrawState* state, struct tb_event* ev);
 char* dirname(char* path);
 void goto_msgid(struct DrawState* state, const size_t msgid_number);
 void handle_key_event(struct tb_event* ev, struct DrawState* state);
 int insert_char(struct DrawState* state, uint32_t ch);
 void insert_search_char(struct DrawState* state, uint32_t ch);
 struct DrawState* join_lines(struct DrawState* state, size_t first_line,
 	int forward);
 struct BufferLine* load_info(struct DrawState* state);
 struct BufferLine* load_msgstr(struct DrawState* state);
 size_t next_msgid(struct DrawState* state, const int delta);
 void overwrite_copy_msgid_callback(struct DrawState* state, struct tb_event* ev);
 void overwrite_paste_callback(struct DrawState* state, struct tb_event* ev);
 size_t prev_msgid(struct DrawState* state, const int delta);
 int print_error(const int code, const char* msg, ...);
 void quit_callback(struct DrawState* state, struct tb_event* ev);
 size_t real_msgid_to_display_msgid(const struct DrawState* state);
 
 void
 cancel_callback(struct DrawState* state, struct tb_event* ev)
 {
 	if (ev->ch == 'y')
 		save_msgstr(state);
 	else
 		cancel_msgstr(state);
 	state->prompt_callback = NULL;
 }
 
 char*
 dirname(char* path)
 {
 	static char* result    = NULL;
 	static const char* dot = ".";
 	char* p		       = NULL;
 	char* slash	       = NULL;
 
 	if (!path || !*path)
 		return NULL;
 
 	free(result);
 	result = malloc(MAXPATH);
 	memset(result, 0, MAXPATH);
 
 	STRLCPY(path, result, MAXPATH);
 	p = result + strlen(result) - 1;
 	if (*p == '/')
 		*p = 0;
 
 	slash = strrchr(result, '/');
 	if (!slash)
 		return (char*)dot;
 
 	*slash = 0;
 
 	return result;
 }
 
 void
 goto_msgid(struct DrawState* state, const size_t msgid_number)
 {
 	size_t last_non_obsolete
 		= state->real_msgid_count - state->obsolete_at_end_count;
 
 	if (msgid_number > state->real_msgid_count)
 		return;
 
 	state->msgid_number = msgid_number;
 
 	if (state->msgid_number < state->first_shown_msgid)
 		state->first_shown_msgid = state->msgid_number;
 	else if (state->msgid_number
 		> state->first_shown_msgid + state->maxy - 2)
 		state->first_shown_msgid
 			= state->msgid_number - (state->maxy - 2);
 	else if (last_non_obsolete < state->msgid_number + state->maxy - 2)
 		state->first_shown_msgid = (last_non_obsolete > state->maxy - 2
 				? last_non_obsolete - (state->maxy - 2)
 				: 1);
 	else
 		;
 }
 
 void
 handle_key_event(struct tb_event* ev, struct DrawState* state)
 {
 	const struct Key* current = NULL;
 
 	*state->error = 0;
 
 	if (state->in_prompt)
 	{
 		if (ev->ch == 'y' || ev->ch == 'n')
 		{
 			if (state->prompt_callback)
 				state->prompt_callback(state, ev);
 			state->in_prompt = 0;
 			*state->prompt	 = 0;
 		}
 		else if (ev->key == TB_KEY_ESC)
 			cancel_close(state);
 		return;
 	}
 
 	/* Remember to also edit the following condition if you reassign motion
 	 * keys */
 	if (ev->key != TB_KEY_ARROW_DOWN && ev->key != TB_KEY_ARROW_UP
 		&& state->show_edit)
 		state->saved_column = -1;
 
 	for (int key = 0; key < LEN(top_level_keys); key++)
 	{
 		current = top_level_keys + key;
 		if (((current->ev.key == ev->key) && !ev->ch)
 			|| (current->ev.ch && (current->ev.ch == ev->ch)))
 			if (current->callback && !current->callback(state))
 				return;
 	}
 
 	if (state->show_help)
 	{
 		STRLCPY(errors[ERR_DLG_OPEN_QUIT], state->error, MAXBUFLINE);
 		return;
 	}
 	else if (state->show_edit)
 	{
 		for (int key = 0; key < LEN(edit_keys); key++)
 		{
 			current = edit_keys + key;
 			if (((current->ev.key == ev->key) && !ev->ch)
 				|| (current->ev.ch
 					&& (current->ev.ch == ev->ch)))
 				if (current->callback
 					&& !current->callback(state))
 					return;
 		}
 		if (!state->edit_info_focused && ev->ch)
 		{
 			insert_char(state, ev->ch);
 			return;
 		}
 	}
 	else if (state->show_search)
 	{
 		for (int key = 0; key < LEN(search_keys); key++)
 		{
 			current = search_keys + key;
 			if (((current->ev.key == ev->key) && !ev->ch)
 				|| (current->ev.ch
 					&& (current->ev.ch == ev->ch)))
 				if (current->callback
 					&& !current->callback(state))
 					return;
 		}
 		if (ev->ch)
 		{
 			insert_search_char(state, ev->ch);
 			return;
 		}
 	}
 	else
 	{
 		for (int key = 0; key < LEN(main_keys); key++)
 		{
 			current = main_keys + key;
 			if (((current->ev.key == ev->key) && !ev->ch)
 				|| (current->ev.ch
 					&& (current->ev.ch == ev->ch)))
 				if (current->callback)
 				{
 					if (!current->callback(state))
 						return;
 					else
 						break;
 				}
 		}
 	}
 
 	if (state->edit_info_focused)
 		STRLCPY(errors[ERR_DLG_FOCUS_EDIT], state->error, MAXBUFLINE);
 	else if (state->show_edit || state->show_search)
 		STRLCPY(errors[ERR_UNKNOWN_KEY], state->error, MAXBUFLINE);
 	else
 		STRLCPY(errors[ERR_UNKNOWN_KEY_HELP], state->error, MAXBUFLINE);
 }
 
 int
 insert_char(struct DrawState* state, uint32_t ch)
 {
 	if (state->edit_info_focused)
 		return 1;
 	struct BufferLine* buffer_line = &state->input_buffer[state->input_row];
 	size_t len		       = buffer_line->length;
 	if (state->input_column < MAXBUFLINE - 1)
 	{
 		size_t i     = len + 1;
 		int add_null = buffer_line->text[state->input_column] == 0;
 		while (i < MAXBUFLINE - 2 && i > state->input_column)
 		{
 			buffer_line->text[i] = buffer_line->text[i - 1];
 			i--;
 		}
 		buffer_line->text[state->input_column++] = ch;
 		buffer_line->length++;
 		if (state->input_column == MAXBUFLINE)
 			state->input_column = MAXBUFLINE - 1;
 		state->input_display_column = display_length(state,
 			state->input_buffer[state->input_row].text,
 			state->input_column);
 		if (state->input_display_column - state->input_first_shown_column
 			> state->edit_width - 4)
 		{
 			state->input_first_shown_column
 				= state->input_display_column
 				- state->edit_width + 4;
 			state->input_display_column = display_length(state,
 				state->input_buffer[state->input_row].text,
 				state->input_column);
 		}
 		if (add_null)
 			buffer_line->text[state->input_column] = 0;
 	}
 	state->dirty = 1;
 	return 0;
 }
 
 void
 insert_search_char(struct DrawState* state, uint32_t ch)
 {
 	size_t len = u32_strlen(state->search);
 	if (state->search_column < MAXSEARCH - 1)
 	{
 		size_t i     = len + 1;
 		int add_null = state->search[state->search_column] == 0;
 		while (i < MAXSEARCH - 2 && i > state->search_column)
 		{
 			state->search[i] = state->search[i - 1];
 			i--;
 		}
 		state->search[state->search_column++] = ch;
 		if (state->search_column == MAXSEARCH)
 			state->search_column = MAXSEARCH - 1;
 		state->search_display_column = display_length(state,
 			state->search, state->search_column);
 		if (state->search_display_column
 				- state->search_first_shown_column
 			> state->search_width - 4)
 		{
 			state->search_first_shown_column
 				= state->search_display_column
 				- state->search_width + 4;
 			state->search_display_column = display_length(state,
 				state->search, state->search_column);
 		}
 		if (add_null)
 			state->search[state->search_column] = 0;
 
 		next_match(state);
 	}
 }
 
 struct DrawState*
 join_lines(struct DrawState* state, size_t first_line, int forward)
 {
 	state->input_column	    = state->input_buffer[first_line].length;
 	state->input_display_column = display_length(state,
 		state->input_buffer[state->input_row].text,
 		state->input_column);
 	u32_strncat(state->input_buffer[first_line].text,
 		state->input_buffer[first_line + 1].text, MAXBUFLINE);
 	state->input_buffer[first_line].length
 		= u32_strlen(state->input_buffer[first_line].text);
 	if (!forward)
 	{
 		state->input_row--;
 		if (state->input_row < 0)
 			state->input_row = 0;
 	}
 	for (size_t i = first_line + 1; i < state->input_rows_count - 1; i++)
 	{
 		u32_strncpy(state->input_buffer[i].text,
 			state->input_buffer[i + 1].text, MAXBUFLINE);
 		state->input_buffer[i].length
 			= state->input_buffer[i + 1].length;
 	}
 	free_bufferline(state->input_buffer + state->input_rows_count - 1);
 	state->input_rows_count--;
 	struct BufferLine* newbuf = realloc(state->input_buffer,
 		state->input_rows_count * sizeof(struct BufferLine));
 	if (!newbuf)
 		return NULL;
 	state->input_buffer = newbuf;
 	state->dirty	    = 1;
 
 	return state;
 }
 
 struct BufferLine*
 load_info(struct DrawState* state)
 {
 	struct PoEntry* first	= &state->entries[0];
 	struct PoEntry* current = &state->entries[state->msgid_number - 1];
 	size_t msgid_num_lines	= u32_lines_in_string(current->msgid, 0, 0);
 	size_t msgid_plural_num_lines
 		= u32_lines_in_string(current->msgid_plural, 0, 0);
 	size_t num_lines	   = 0;
 	struct BufferLine* newbuf  = NULL;
 	struct BufferLine* pnewbuf = NULL;
 
 	for (size_t i = 0; i < state->info_rows_count; i++)
 		free_bufferline(state->info_buffer + i);
 	free(state->info_buffer);
 
 	state->info_rows_maxlen = 0;
 
 	if (current->msgid)
 		num_lines += msgid_num_lines + 1;
 	if (current->msgid_plural)
 	{
 		num_lines += msgid_plural_num_lines + 1;
 		if (first->plural_forms)
 			num_lines += 3;
 	}
 	if (current->comments)
 		num_lines += current->comment_lines + 1;
 	if (current->trans_comments)
 		num_lines += current->trans_comment_lines + 1;
 	if (current->ref_comments)
 		num_lines += current->ref_comment_lines + 1;
 	newbuf = calloc(num_lines, sizeof(struct BufferLine));
 	if (!newbuf)
 		return NULL;
 
 	pnewbuf = newbuf;
 	for (size_t i = 0; i < num_lines; i++)
 	{
 		init_bufferline(pnewbuf);
 		uint32_t* newtext = calloc(MAXBUFLINE, sizeof(uint32_t));
 		if (!newtext)
 			return NULL;
 		pnewbuf->text = newtext;
 		pnewbuf++;
 	}
 
 	state->info_rows_count = num_lines;
 
 	pnewbuf			= newbuf;
 	size_t newlen		= 0;
 	const uint32_t* pumsgid = NULL;
 	if (current->msgid)
 	{
 		pumsgid = current->msgid;
 		newlen	= u32_u8_strncpy(pnewbuf->text, "msgid:", MAXBUFLINE);
 		pnewbuf->length = newlen;
 		if (newlen > state->info_rows_maxlen)
 			state->info_rows_maxlen = newlen;
 		pnewbuf->fg = EDIT_MSGID_HEADING_FG;
 		pnewbuf->bg = EDIT_MSGID_HEADING_BG;
 		pnewbuf++;
 		while (*pumsgid)
 		{
 			size_t len		    = 0;
 			const uint32_t* old_pumsgid = pumsgid;
 
 			len = u32_next_line(current->msgid, &pumsgid, 0, 0);
 			u32_strncpy(pnewbuf->text, old_pumsgid,
 				MIN(len + 1, MAXBUFLINE));
 			newlen = u32_decode_tabs(pnewbuf->text, MAXBUFLINE);
 			pnewbuf->length = newlen;
 			if (newlen > state->info_rows_maxlen)
 				state->info_rows_maxlen = newlen;
 			pnewbuf++;
 		}
 	}
 	if (current->msgid_plural)
 	{
 		newlen		= u32_u8_strncpy(pnewbuf->text,
 				 "msgid_plural:", MAXBUFLINE);
 		pnewbuf->length = newlen;
 		if (newlen > state->info_rows_maxlen)
 			state->info_rows_maxlen = newlen;
 		pnewbuf->fg = EDIT_MSGID_HEADING_FG;
 		pnewbuf->bg = EDIT_MSGID_HEADING_BG;
 		pnewbuf++;
 		pumsgid = current->msgid_plural;
 		while (*pumsgid)
 		{
 			size_t len		    = 0;
 			const uint32_t* old_pumsgid = pumsgid;
 
 			len = u32_next_line(current->msgid_plural, &pumsgid, 0,
 				0);
 			u32_strncpy(pnewbuf->text, old_pumsgid,
 				MIN(len + 1, MAXBUFLINE));
 			newlen = u32_decode_tabs(pnewbuf->text, MAXBUFLINE);
 			pnewbuf->length = newlen;
 			if (newlen > state->info_rows_maxlen)
 				state->info_rows_maxlen = newlen;
 			pnewbuf++;
 		}
 		if (first->plural_forms)
 		{
 			newlen		= u32_u8_strncpy(pnewbuf->text,
 					 "Plural forms:", MAXBUFLINE);
 			pnewbuf->length = newlen;
 			if (newlen > state->info_rows_maxlen)
 				state->info_rows_maxlen = newlen;
 			pnewbuf->fg = EDIT_MSGID_HEADING_FG;
 			pnewbuf->bg = EDIT_MSGID_HEADING_BG;
 			pnewbuf++;
 			newlen = u32_strncpy(pnewbuf->text, first->plural_forms,
 				MAXBUFLINE);
 			pnewbuf->length = newlen;
 			if (newlen > state->info_rows_maxlen)
 				state->info_rows_maxlen = newlen;
 			pnewbuf++;
 		}
 	}
 	if (current->comments)
 	{
 		newlen = u32_u8_strncpy(pnewbuf->text, "Comments:", MAXBUFLINE);
 		pnewbuf->length = newlen;
 		if (newlen > state->info_rows_maxlen)
 			state->info_rows_maxlen = newlen;
 		pnewbuf->fg = EDIT_MSGID_HEADING_FG;
 		pnewbuf->bg = EDIT_MSGID_HEADING_BG;
 		pnewbuf++;
 		for (size_t i = 0; i < current->comment_lines; i++)
 		{
 			uint32_t* comment = current->comments[i];
 			size_t len	  = u32_strlen(comment);
 			newlen		  = u32_strncpy(pnewbuf->text, comment,
 					   MIN(len + 1, MAXBUFLINE));
 			pnewbuf->length	  = newlen;
 			if (newlen > state->info_rows_maxlen)
 				state->info_rows_maxlen = newlen;
 			pnewbuf++;
 		}
 	}
 	if (current->trans_comments)
 	{
 		newlen		= u32_u8_strncpy(pnewbuf->text,
 				 "Translation comments:", MAXBUFLINE);
 		pnewbuf->length = newlen;
 		if (newlen > state->info_rows_maxlen)
 			state->info_rows_maxlen = newlen;
 		pnewbuf->fg = EDIT_MSGID_HEADING_FG;
 		pnewbuf->bg = EDIT_MSGID_HEADING_BG;
 		pnewbuf++;
 		for (size_t i = 0; i < current->trans_comment_lines; i++)
 		{
 			uint32_t* trans_comment = current->trans_comments[i];
 			size_t len		= u32_strlen(trans_comment);
 			newlen = u32_strncpy(pnewbuf->text, trans_comment,
 				MIN(len + 1, MAXBUFLINE));
 			pnewbuf->length = newlen;
 			if (newlen > state->info_rows_maxlen)
 				state->info_rows_maxlen = newlen;
 			pnewbuf++;
 		}
 	}
 	if (current->ref_comments)
 	{
 		newlen		= u32_u8_strncpy(pnewbuf->text,
 				 "References:", MAXBUFLINE);
 		pnewbuf->length = newlen;
 		if (newlen > state->info_rows_maxlen)
 			state->info_rows_maxlen = newlen;
 		pnewbuf->fg = EDIT_MSGID_HEADING_FG;
 		pnewbuf->bg = EDIT_MSGID_HEADING_BG;
 		pnewbuf++;
 		for (size_t i = 0; i < current->ref_comment_lines; i++)
 		{
 			char* ref_comment = current->ref_comments[i];
 			size_t len	  = strlen(ref_comment);
 			newlen = u32_u8_strncpy(pnewbuf->text, ref_comment,
 				MIN(len + 1, MAXBUFLINE));
 			pnewbuf->length = newlen;
 			if (newlen > state->info_rows_maxlen)
 				state->info_rows_maxlen = newlen;
 			pnewbuf++;
 		}
 	}
 
 	state->info_buffer = newbuf;
 
 	return state->info_buffer;
 }
 
 struct BufferLine*
 load_msgstr(struct DrawState* state)
 {
 	int msgstr_index	   = state->msgstr_index;
 	struct PoEntry* current	   = &state->entries[state->msgid_number - 1];
 	size_t num_lines	   = current->msgstr_count == 0
 			  ? 1
 			  : u32_lines_in_string(*(current->msgstr + msgstr_index), 0, 0);
 	struct BufferLine* newbuf  = NULL;
 	struct BufferLine* pnewbuf = NULL;
 
 	for (size_t i = 0; i < state->input_rows_count; i++)
 		free_bufferline(state->input_buffer + i);
 	free(state->input_buffer);
 
 	newbuf = calloc(num_lines, sizeof(struct BufferLine));
 	if (!newbuf)
 		return NULL;
 
 	pnewbuf = newbuf;
 	for (size_t i = 0; i < num_lines; i++)
 	{
 		init_bufferline(pnewbuf);
 		uint32_t* newtext = calloc(MAXBUFLINE, sizeof(uint32_t));
 		if (!newtext)
 			return NULL;
 		pnewbuf->text = newtext;
 		pnewbuf++;
 	}
 
 	state->input_rows_count = num_lines;
 
 	if (current->msgstr_count > 0)
 	{
 		const uint32_t* pumsgstr = *(current->msgstr + msgstr_index);
 		if (pumsgstr)
 		{
 			pnewbuf = newbuf;
 			while (*pumsgstr)
 			{
 				size_t len		     = 0;
 				size_t newlen		     = 0;
 				const uint32_t* old_pumsgstr = pumsgstr;
 				len = u32_next_line(*(current->msgstr
 							    + msgstr_index),
 					&pumsgstr, 0, 0);
 				u32_strncpy(pnewbuf->text, old_pumsgstr,
 					MIN(len + 1, MAXBUFLINE));
 				newlen		= u32_decode_tabs(pnewbuf->text,
 						 MAXBUFLINE);
 				pnewbuf->length = newlen;
 				pnewbuf++;
 			}
 		}
 		else
 			newbuf[0].length = 0;
 	}
 	else
 		newbuf[0].length = 0;
 
 	state->input_buffer = newbuf;
 	return state->input_buffer;
 }
 
 size_t
 next_msgid(struct DrawState* state, const int delta)
 {
 	size_t ret   = state->msgid_number;
 	size_t start = ret;
 	size_t last_non_obsolete
 		= state->real_msgid_count - state->obsolete_at_end_count;
 
 	while (ret < last_non_obsolete + 1)
 	{
 		ret++;
 		if (!state->entries[ret - 1].obsolete && ret >= start + delta)
 			break;
 	}
 
 	return ret == last_non_obsolete + 1 ? last_non_obsolete : ret;
 }
 
 void
 overwrite_copy_msgid_callback(struct DrawState* state, struct tb_event* ev)
 {
 	if (ev->ch == 'y')
 		copy_msgid_to_input(state);
 	state->prompt_callback = NULL;
 }
 
 void
 overwrite_paste_callback(struct DrawState* state, struct tb_event* ev)
 {
 	if (ev->ch == 'y')
 		paste_paste_buffer_to_input(state);
 	state->prompt_callback = NULL;
 }
 
 size_t
 prev_msgid(struct DrawState* state, const int delta)
 {
 	size_t ret   = state->msgid_number;
 	size_t start = ret;
 
 	if (start < delta)
 		return state->real_msgid_count ? 1 : 0;
 
 	while (ret > 1)
 	{
 		ret--;
 		if (!state->entries[ret - 1].obsolete && ret <= start - delta)
 			break;
 	}
 
 	return ret;
 }
 
 int
 print_error(const int code, const char* msg, ...)
 {
 	char buf[MAXBUFLINE];
 	va_list args;
 	va_start(args, msg);
 	vsnprintf(buf, sizeof(buf), msg, args);
 	va_end(args);
 	fprintf(stderr, "%s: %s\n", PROGRAMNAME, buf);
 	return code;
 }
 
 void
 quit_callback(struct DrawState* state, struct tb_event* ev)
 {
 	if (ev->ch == 'y')
 		write_file(state);
 	state->prompt_callback = NULL;
 	state->running	       = 0;
 }
 
 size_t
 real_msgid_to_display_msgid(const struct DrawState* state)
 {
 	struct PoEntry* current = state->entries;
 	size_t ret		= 1;
 
 	if (!state->msgid_count)
 		return 0;
 
 	while (current != state->entries + state->msgid_number - 1)
 	{
 		if (current != state->entries + state->msgid_number - 1
 			&& !current->obsolete)
 			ret++;
 		current++;
 	}
 
 	return ret;
 }
 
 int
 cancel_close(struct DrawState* state)
 {
 	*state->error = 0;
 	if (state->in_prompt)
 	{
 		state->in_prompt = 0;
 		*state->prompt	 = 0;
 	}
 	else if (state->show_help)
 		state->show_help = 0;
 	else if (state->show_edit)
 		cancel_msgstr(state);
 	else if (state->show_search)
 		cancel_search(state);
 	else
 		STRLCPY(errors[ERR_EXIT_KEY], state->error, MAXBUFLINE);
 
 	return 0;
 }
 
 int
 cancel_msgstr(struct DrawState* state)
 {
 	if (!state->in_prompt && state->dirty)
 	{
 		state->in_prompt = 1;
 		STRLCPY(prompt_cancel_dirty, state->prompt, MAXBUFLINE);
 		state->prompt_callback = cancel_callback;
 		return 0;
 	}
 
 	state->show_edit	 = 0;
 	state->edit_info_focused = 0;
 
 	for (size_t i = 0; i < state->input_rows_count; i++)
 		free_bufferline(state->input_buffer + i);
 	free(state->input_buffer);
 	state->input_buffer	= NULL;
 	state->input_rows_count = 0;
 	if (state->info_buffer)
 		for (size_t i = 0; i < state->info_rows_count; i++)
 			free_bufferline(state->info_buffer + i);
 	free(state->info_buffer);
 	state->info_buffer     = NULL;
 	state->info_rows_count = 0;
 	state->dirty	       = state->dirty_before_edit;
 	state->fuzzy_count     = state->fuzzy_before_edit;
 	switch (state->input_changed_fuzzy)
 	{
 	case SET:
 		state->entries[state->msgid_number - 1].flags &= ~FL_FUZZY;
 		break;
 	case CLEARED:
 		state->entries[state->msgid_number - 1].flags |= FL_FUZZY;
 		break;
 	default:;
 	}
 	state->input_changed_fuzzy = UNCHANGED;
 	tb_hide_cursor();
 	return 0;
 }
 
 int
 cancel_search(struct DrawState* state)
 {
 	state->show_search = 0;
 	*state->search	   = 0;
 	tb_hide_cursor();
 	return 0;
 }
 
 int
 copy_msgid_to_input(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 		return 0;
 
 	if (!state->in_prompt && *state->input_buffer->text)
 	{
 		state->in_prompt = 1;
 		STRLCPY(prompt_overwrite, state->prompt, MAXBUFLINE);
 		state->prompt_callback = overwrite_copy_msgid_callback;
 		return 0;
 	}
 
 	if (state->msgid_number == 1)
 	{
 		STRLCPY(errors[ERR_ILLEGAL_ON_FIRST], state->error, MAXBUFLINE);
 		return 0;
 	}
 
 	struct PoEntry* current = &state->entries[state->msgid_number - 1];
 	size_t msgid_num_lines	= u32_lines_in_string(current->msgid, 0, 0);
 	size_t lines_to_init	= state->input_rows_count < msgid_num_lines
 		   ? msgid_num_lines - state->input_rows_count
 		   : 0;
 	size_t lines_to_free	= state->input_rows_count > msgid_num_lines
 		   ? state->input_rows_count - msgid_num_lines
 		   : 0;
 	for (size_t i = 0; i < lines_to_free; i++)
 		free_bufferline(
 			state->input_buffer + state->input_rows_count - i - 1);
 	struct BufferLine* newbuf = realloc(state->input_buffer,
 		msgid_num_lines * sizeof(struct BufferLine));
 	const uint32_t* pmsgid	  = current->msgid;
 
 	if (!newbuf)
 		return 0;
 
 	struct BufferLine* pbuffer = NULL;
 	for (size_t i = 0; i < lines_to_init; i++)
 	{
 		pbuffer = newbuf + msgid_num_lines - 1 - i;
 		init_bufferline(pbuffer);
 		uint32_t* newtext = calloc(MAXBUFLINE, sizeof(uint32_t));
 		if (!newtext)
 			return 0;
 		pbuffer->text = newtext;
 	}
 
 	pbuffer = newbuf;
 	while (pmsgid && *pmsgid)
 	{
 		size_t len		   = 0;
 		size_t newlen		   = 0;
 		const uint32_t* old_pmsgid = pmsgid;
 		len = u32_next_line(current->msgid, &pmsgid, 0, 0);
 		u32_strncpy(pbuffer->text, old_pmsgid, MIN(len + 1, MAXBUFLINE));
 		newlen		= u32_decode_tabs(pbuffer->text, MAXBUFLINE);
 		pbuffer->length = newlen;
 		pbuffer++;
 	}
 
 	state->input_rows_count = msgid_num_lines;
 	state->input_buffer	= newbuf;
 	state->dirty		= 1;
 
 	return 0;
 }
 
 int
 edit_page_down(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown_row + (EDIT_HEIGHT - 3) / 2
 			< state->info_rows_count - 1)
 			state->info_first_shown_row += (EDIT_HEIGHT - 3) / 2;
 		return 0;
 	}
 
 	if (state->dirty)
 		save_msgstr(state);
 	else /* No need to call cancel_msgstr */
 		state->dirty = state->dirty_before_edit;
 	move_list_down(state);
 	state->msgstr_index = 0;
 	return show_edit(state);
 }
 
 int
 edit_page_up(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown_row > (EDIT_HEIGHT - 3) / 2)
 			state->info_first_shown_row -= (EDIT_HEIGHT - 3) / 2;
 		else
 			move_start(state);
 		return 0;
 	}
 
 	if (state->dirty)
 		save_msgstr(state);
 	else /* No need to call cancel_msgstr */
 		state->dirty = state->dirty_before_edit;
 	move_list_up(state);
 	state->msgstr_index = 0;
 	return show_edit(state);
 }
 
 int
 erase_backwards(struct DrawState* state)
 {
 	struct BufferLine* buffer_line = &state->input_buffer[state->input_row];
 	if (state->edit_info_focused)
 		return 1;
 
 	if (state->input_column > 0)
 	{
 		size_t i = state->input_column;
 		do
 		{
 			buffer_line->text[i - 1] = buffer_line->text[i];
 			i++;
 		} while (buffer_line->text[i]);
 		buffer_line->text[i - 1] = 0;
 		buffer_line->length--;
 		state->input_column--;
 		if (state->input_first_shown_column > 0)
 		{
 			const struct BufferLine* current_line
 				= &state->input_buffer[state->input_row];
 			if (display_length(state, current_line->text,
 				    current_line->length)
 				>= state->edit_width - 4)
 				state->input_first_shown_column--;
 		}
 		state->input_display_column = display_length(state,
 			state->input_buffer[state->input_row].text,
 			state->input_column);
 		if (state->input_display_column
 			< state->input_first_shown_column)
 			state->input_first_shown_column
 				= state->input_display_column;
 		state->dirty = 1;
 	}
 	else if (state->input_row > 0)
 	{
 		move_up(state);
 		move_end(state);
 		erase_forward(state);
 	}
 	return 0;
 }
 
 int
 erase_forward(struct DrawState* state)
 {
 	struct BufferLine* buffer_line = &state->input_buffer[state->input_row];
 	if (state->edit_info_focused)
 		return 1;
 
 	if (buffer_line->text[state->input_column])
 	{
 		size_t i = state->input_column;
 		while (i < MAXBUFLINE - 2 && buffer_line->text[i + 1])
 		{
 			buffer_line->text[i] = buffer_line->text[i + 1];
 			i++;
 		}
 		buffer_line->text[i] = 0;
 		buffer_line->length--;
 		state->dirty = 1;
 	}
 	else if (state->input_row < state->input_rows_count - 1)
 	{
 		if (!join_lines(state, state->input_row, 1))
 		{
 			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
 				MAXBUFLINE);
 			state->running = 0;
 		}
 	}
 	return 0;
 }
 
 int
 erase_prev_word(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 		return 1;
 
 	int i	   = state->input_column;
 	size_t len = state->input_buffer[state->input_row].length;
 
 	uint32_t* pline = state->input_buffer[state->input_row].text;
 
 	if (i > 0 && u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 	while (i > 0 && u32_is_word_boundary(pline[i], 0))
 		i--;
 	while (i > 0 && !u32_is_word_boundary(pline[i], 0)
 		&& !u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 
 	int d = state->input_column - i;
 
 	for (int j = i; j < len - d; j++)
 		pline[j] = pline[j + d];
 
 	len -= d;
 	state->input_buffer[state->input_row].length = len;
 	pline[len]				     = 0;
 	state->input_column			     = i;
 	state->input_display_column		     = display_length(state,
 				 state->input_buffer[state->input_row].text,
 				 state->input_column);
 	if (state->input_display_column < state->input_first_shown_column)
 		state->input_first_shown_column = state->input_display_column;
 	state->dirty = 1;
 	return 0;
 }
 
 int
 erase_search_backwards(struct DrawState* state)
 {
 	if (state->search_column > 0)
 	{
 		size_t i = state->search_column;
 		do
 		{
 			state->search[i - 1] = state->search[i];
 			i++;
 		} while (state->search[i]);
 		state->search[i - 1] = 0;
 		state->search_column--;
 		if (state->search_column < state->search_first_shown_column)
 		{
 			if (state->search_column > state->search_width - 4)
 				state->search_first_shown_column
 					= state->search_column
 					- state->search_width + 4;
 			else
 				state->search_first_shown_column = 0;
 		}
 		state->search_display_column = display_length(state,
 			state->search, state->search_column);
 
 		return next_match(state);
 	}
 	return 0;
 }
 
 int
 erase_search_forward(struct DrawState* state)
 {
 	if (state->search[state->search_column])
 	{
 		size_t i = state->search_column;
 		while (i < MAXSEARCH - 2 && state->search[i + 1])
 		{
 			state->search[i] = state->search[i + 1];
 			i++;
 		}
 		state->search[i] = 0;
 
 		return next_match(state);
 	}
 	return 0;
 }
 
 int
 erase_search_prev_word(struct DrawState* state)
 {
 	int i	   = state->search_column;
 	size_t len = u32_strlen(state->search);
 
 	uint32_t* pline = state->search;
 
 	if (i > 0 && u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 	while (i > 0 && u32_is_word_boundary(pline[i], 0))
 		i--;
 	while (i > 0 && !u32_is_word_boundary(pline[i], 0)
 		&& !u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 
 	int d = state->search_column - i;
 
 	for (int j = i; j < len - d; j++)
 		pline[j] = pline[j + d];
 
 	len -= state->search_column - i;
 	pline[len]	     = 0;
 	state->search_column = i;
 	state->search_display_column
 		= display_length(state, state->search, state->search_column);
 
 	if (state->search_column < state->search_first_shown_column)
 	{
 		if (state->search_column > state->search_width - 4)
 			state->search_first_shown_column = state->search_column
 				- state->search_width + 4;
 		else
 			state->search_first_shown_column = 0;
 	}
 	state->search_display_column
 		= display_length(state, state->search, state->search_column);
 
 	return next_match(state);
 }
 
 int
 erase_search_to_end(struct DrawState* state)
 {
 	state->search[state->search_column] = 0;
 	move_search_end(state);
 	return next_match(state);
 }
 
 int
 erase_search_to_start(struct DrawState* state)
 {
 	size_t i   = state->search_column;
 	size_t len = u32_strlen(state->search);
 	do
 	{
 		state->search[i - state->search_column] = state->search[i];
 		i++;
 	} while (state->search[i]);
 	state->search[len - state->search_column] = 0;
 	move_search_start(state);
 	return next_match(state);
 }
 
 int
 erase_to_end(struct DrawState* state)
 {
 	struct BufferLine* buffer_line = NULL;
 
 	if (state->edit_info_focused)
 		return 1;
 
 	buffer_line = &state->input_buffer[state->input_row];
 	buffer_line->text[state->input_column] = 0;
 	buffer_line->length		       = state->input_column;
 	move_end(state);
 	state->dirty = 1;
 	return 0;
 }
 
 int
 erase_to_start(struct DrawState* state)
 {
 	size_t i		       = state->input_column;
 	struct BufferLine* buffer_line = &state->input_buffer[state->input_row];
 	size_t len		       = buffer_line->length;
 
 	if (state->edit_info_focused)
 		return 1;
 
 	do
 	{
 		buffer_line->text[i - state->input_column]
 			= buffer_line->text[i];
 		i++;
 	} while (buffer_line->text[i]);
 	buffer_line->text[len - state->input_column] = 0;
 	buffer_line->length = len - state->input_column;
 	move_start(state);
 	state->dirty = 1;
 	return 0;
 }
 
 int
 exit_program(struct DrawState* state)
 {
 	if (state->show_edit)
 	{
 		STRLCPY(errors[ERR_DLG_OPEN], state->error, MAXBUFLINE);
 		return 0;
 	}
 	if (state->dirty)
 	{
 		state->in_prompt = 1;
 		STRLCPY(prompt_dirty, state->prompt, MAXBUFLINE);
 		state->prompt_callback = quit_callback;
 	}
 	else
 		state->running = 0;
 	*state->error = 0;
 	return 0;
 }
 
 int
 hide_search(struct DrawState* state)
 {
 	state->show_search = 0;
 	tb_hide_cursor();
 	return 0;
 }
 
 int
 insert_line(struct DrawState* state)
 {
 	struct BufferLine* newbuf = NULL;
 
 	if (state->edit_info_focused)
 		return 1;
 
 	state->input_rows_count++;
 	newbuf = realloc(state->input_buffer,
 		state->input_rows_count * sizeof(struct BufferLine));
 	if (!newbuf)
 	{
 		STRLCPY(errors[ERR_CANT_ALLOC], state->error, MAXBUFLINE);
 		state->running = 0;
 		return 0;
 	}
 
 	state->input_buffer = newbuf;
 	init_bufferline(&state->input_buffer[state->input_rows_count - 1]);
 	uint32_t* newtext = calloc(MAXBUFLINE, sizeof(uint32_t));
 	if (!newtext)
 	{
 		STRLCPY(errors[ERR_CANT_ALLOC], state->error, MAXBUFLINE);
 		state->running = 0;
 		return 0;
 	}
 	state->input_buffer[state->input_rows_count - 1].text = newtext;
 	for (size_t i = state->input_rows_count - 1; i > state->input_row + 1;
 		i--)
 	{
 		u32_strncpy(state->input_buffer[i].text,
 			state->input_buffer[i - 1].text, MAXBUFLINE);
 		state->input_buffer[i].length
 			= state->input_buffer[i - 1].length;
 	}
 	u32_strncpy(state->input_buffer[state->input_row + 1].text,
 		state->input_buffer[state->input_row].text + state->input_column,
 		MAXBUFLINE);
 	state->input_buffer[state->input_row + 1].length
 		= u32_strlen(state->input_buffer[state->input_row + 1].text);
 	state->input_buffer[state->input_row].text[state->input_column] = 0;
 	state->input_buffer[state->input_row].length
 		= u32_strlen(state->input_buffer[state->input_row].text);
 
 	state->input_row++;
 	if (state->input_row
 		> state->input_first_shown_row + (EDIT_HEIGHT - 3) / 2)
 		state->input_first_shown_row
 			= state->input_row - (EDIT_HEIGHT - 3) / 2;
 	move_start(state);
 	state->dirty = 1;
 
 	return 0;
 }
 
 int
 insert_search_space(struct DrawState* state)
 {
 	insert_search_char(state, (uint32_t)L' ');
 	return 0;
 }
 
 int
 insert_search_tab(struct DrawState* state)
 {
 	insert_search_char(state, (uint32_t)L'\t');
 	return 0;
 }
 
 int
 insert_space(struct DrawState* state)
 {
 	insert_char(state, (uint32_t)L' ');
 	return 0;
 }
 
 int
 insert_tab(struct DrawState* state)
 {
 	insert_char(state, (uint32_t)L'\t');
 	return 0;
 }
 
 int
 move_end(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 	{
 		if (state->info_rows_count > (EDIT_HEIGHT - 3) / 2)
 			state->info_first_shown_row = state->info_rows_count
 				- (EDIT_HEIGHT - 3) / 2;
 		state->info_first_shown_column = 0;
 		return 0;
 	}
 
 	size_t len	    = state->input_buffer[state->input_row].length;
 	state->input_column = len;
 	size_t dlen	    = display_length(state,
 			state->input_buffer[state->input_row].text,
 			state->input_column);
 	state->input_display_column = dlen;
 	if (dlen > state->edit_width - 4)
 		state->input_first_shown_column = dlen - state->edit_width + 4;
 	else
 		state->input_first_shown_column = 0;
 	return 0;
 }
 
 int
 move_down(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown_row + (EDIT_HEIGHT - 3) / 2
 			< state->info_rows_count)
 			state->info_first_shown_row++;
 		return 0;
 	}
 
 	if (state->input_row < state->input_rows_count - 1)
 		state->input_row++;
 	if (state->input_first_shown_row + (EDIT_HEIGHT - 3) / 2
 		< state->input_row)
 		state->input_first_shown_row
 			= state->input_row - (EDIT_HEIGHT - 3) / 2;
 	if (state->saved_column == -1)
 		state->saved_column = state->input_display_column;
 	size_t dlen = display_length(state,
 		state->input_buffer[state->input_row].text,
 		state->input_buffer[state->input_row].length);
 	if (dlen < state->saved_column)
 		state->input_display_column = dlen;
 	else
 		state->input_display_column = state->saved_column;
 	state->input_column = input_length(state,
 		state->input_buffer[state->input_row].text,
 		state->input_display_column);
 	if (state->input_first_shown_column > state->input_display_column)
 		state->input_first_shown_column = state->input_display_column;
 	if (state->input_first_shown_column + state->edit_width - 4
 		< state->input_display_column)
 		state->input_first_shown_column
 			= state->input_display_column - state->edit_width + 4;
 	state->input_display_column = display_length(state,
 		state->input_buffer[state->input_row].text,
 		state->input_column);
 	return 0;
 }
 
 int
 move_left(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown_column > 0)
 			state->info_first_shown_column--;
 		return 0;
 	}
 
 	if (state->input_column == 0)
 		return 0;
 
 	if (state->input_buffer[state->input_row].text[state->input_column - 1]
 		== '\t')
 		state->input_display_column = display_length(state,
 			state->input_buffer[state->input_row].text,
 			state->input_column - 1);
 	else
 		state->input_display_column--;
 	state->input_column--;
 
 	if (state->input_display_column < state->input_first_shown_column)
 		state->input_first_shown_column = state->input_display_column;
 	return 0;
 }
 
 int
 move_list_down(struct DrawState* state)
 {
 	goto_msgid(state, next_msgid(state, 1));
 	return 0;
 }
 
 int
 move_list_end(struct DrawState* state)
 {
 	goto_msgid(state,
 		next_msgid(state,
 			state->real_msgid_count - state->msgid_number));
 	return 0;
 }
 
 int
 move_list_page_down(struct DrawState* state)
 {
 	*state->error = 0;
 	goto_msgid(state, next_msgid(state, state->maxy - 2));
 	return 0;
 }
 
 int
 move_list_page_up(struct DrawState* state)
 {
 	*state->error = 0;
 	goto_msgid(state, prev_msgid(state, state->maxy - 2));
 	return 0;
 }
 
 int
 move_list_start(struct DrawState* state)
 {
 	goto_msgid(state, 1);
 	return 0;
 }
 
 int
 move_list_up(struct DrawState* state)
 {
 	goto_msgid(state, prev_msgid(state, 1));
 	return 0;
 }
 
 int
 move_next_word(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 		return 1;
 
 	int i		= state->input_column;
 	uint32_t* pline = state->input_buffer[state->input_row].text;
 	size_t len	= state->input_buffer[state->input_row].length;
 
 	while (i < len && !u32_is_word_boundary(pline[i], 0))
 		i++;
 	while (i < len && u32_is_word_boundary(pline[i], 0))
 		i++;
 	state->input_column	    = i;
 	state->input_display_column = display_length(state,
 		state->input_buffer[state->input_row].text,
 		state->input_column);
 	if (state->input_display_column - state->input_first_shown_column
 		> state->edit_width - 4)
 		state->input_first_shown_column
 			= state->input_display_column - state->edit_width + 4;
 	return 0;
 }
 
 int
 move_prev_word(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 		return 1;
 
 	int i		= state->input_column;
 	uint32_t* pline = state->input_buffer[state->input_row].text;
 
 	if (i > 0 && u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 	while (i > 0 && u32_is_word_boundary(pline[i], 0))
 		i--;
 	while (i > 0 && !u32_is_word_boundary(pline[i], 0)
 		&& !u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 
 	state->input_column	    = i;
 	state->input_display_column = display_length(state,
 		state->input_buffer[state->input_row].text,
 		state->input_column);
 	if (state->input_display_column < state->input_first_shown_column)
 		state->input_first_shown_column = state->input_display_column;
 	return 0;
 }
 
 int
 move_right(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown_column + state->edit_width - 3
 			< state->info_rows_maxlen + 1)
 			state->info_first_shown_column++;
 		return 0;
 	}
 
 	size_t len = state->input_buffer[state->input_row].length;
 	if (state->input_column == len)
 		return 0;
 
 	if (state->input_buffer[state->input_row].text[state->input_column]
 		== '\t')
 		state->input_display_column = display_length(state,
 			state->input_buffer[state->input_row].text,
 			state->input_column + 1);
 	else
 		state->input_display_column++;
 	state->input_column++;
 
 	if (state->input_display_column - state->input_first_shown_column
 		> state->edit_width - 4)
 		state->input_first_shown_column
 			= state->input_display_column - state->edit_width + 4;
 	return 0;
 }
 
 int
 move_search_end(struct DrawState* state)
 {
 	size_t len	     = u32_strlen(state->search);
 	state->search_column = len;
 	size_t dlen
 		= display_length(state, state->search, state->search_column);
 	state->search_display_column = dlen;
 	if (dlen > state->search_width - 4)
 		state->search_first_shown_column
 			= dlen - state->search_width + 4;
 	else
 		state->search_first_shown_column = 0;
 	return 0;
 }
 
 int
 move_search_left(struct DrawState* state)
 {
 	if (state->search_column == 0)
 		return 0;
 
 	if (state->search[state->search_column - 1] == '\t')
 		state->search_display_column = display_length(state,
 			state->search, state->search_column - 1);
 	else
 		state->search_display_column--;
 	state->search_column--;
 
 	if (state->search_display_column < state->search_first_shown_column)
 		state->search_first_shown_column = state->search_display_column;
 	return 0;
 }
 
 int
 move_search_next_word(struct DrawState* state)
 {
 	int i		= state->search_column;
 	uint32_t* pline = state->search;
 	size_t len	= u32_strlen(state->search);
 
 	while (i < len && !u32_is_word_boundary(pline[i], 0))
 		i++;
 	while (i < len && u32_is_word_boundary(pline[i], 0))
 		i++;
 	state->search_column = i;
 	state->search_display_column
 		= display_length(state, state->search, state->search_column);
 
 	if (state->search_display_column - state->search_first_shown_column
 		> state->search_width - 4)
 	{
 		state->search_first_shown_column = state->search_display_column
 			- state->search_width + 4;
 		state->search_display_column = display_length(state,
 			state->search, state->search_column);
 	}
 	return 0;
 }
 
 int
 move_search_prev_word(struct DrawState* state)
 {
 	int i		= state->search_column;
 	uint32_t* pline = state->search;
 
 	if (i > 0 && u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 	while (i > 0 && u32_is_word_boundary(pline[i], 0))
 		i--;
 	while (i > 0 && !u32_is_word_boundary(pline[i], 0)
 		&& !u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 
 	state->search_column = i;
 	state->search_display_column
 		= display_length(state, state->search, state->search_column);
 
 	if (state->search_column < state->search_first_shown_column)
 	{
 		if (state->search_column > state->search_width - 4)
 			state->search_first_shown_column = state->search_column
 				- state->search_width + 4;
 		else
 			state->search_first_shown_column = 0;
 	}
 	state->search_display_column
 		= display_length(state, state->search, state->search_column);
 	return 0;
 }
 
 int
 move_search_right(struct DrawState* state)
 {
 	size_t len = u32_strlen(state->search);
 	if (state->search_column == len)
 		return 0;
 
 	if (state->search[state->search_column] == '\t')
 		state->search_display_column = display_length(state,
 			state->search, state->search_column + 1);
 	else
 		state->search_display_column++;
 	state->search_column++;
 
 	if (state->search_display_column - state->search_first_shown_column
 		> state->search_width - 4)
 		state->search_first_shown_column = state->search_display_column
 			- state->search_width + 4;
 	return 0;
 }
 
 int
 move_search_start(struct DrawState* state)
 {
 	state->search_column		 = 0;
 	state->search_display_column	 = 0;
 	state->search_first_shown_column = 0;
 	return 0;
 }
 
 int
 move_start(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 	{
 		state->info_first_shown_row    = 0;
 		state->info_first_shown_column = 0;
 		return 0;
 	}
 
 	state->input_column		= 0;
 	state->input_display_column	= 0;
 	state->input_first_shown_column = 0;
 	return 0;
 }
 
 int
 move_up(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown_row > 0)
 			state->info_first_shown_row--;
 		return 0;
 	}
 
 	if (state->input_row > 0)
 		state->input_row--;
 	if (state->input_first_shown_row > state->input_row)
 		state->input_first_shown_row = state->input_row;
 	if (state->saved_column == -1)
 		state->saved_column = state->input_display_column;
 	size_t dlen = display_length(state,
 		state->input_buffer[state->input_row].text,
 		state->input_buffer[state->input_row].length);
 	if (dlen < state->saved_column)
 		state->input_display_column = dlen;
 	else
 		state->input_display_column = state->saved_column;
 	state->input_column = input_length(state,
 		state->input_buffer[state->input_row].text,
 		state->input_display_column);
 	if (state->input_first_shown_column > state->input_display_column)
 		state->input_first_shown_column = state->input_display_column;
 	if (state->input_first_shown_column + state->edit_width - 4
 		< state->input_display_column)
 		state->input_first_shown_column
 			= state->input_display_column - state->edit_width + 4;
 	state->input_display_column = display_length(state,
 		state->input_buffer[state->input_row].text,
 		state->input_column);
 	return 0;
 }
 
 int
 next_fuzzy(struct DrawState* state)
 {
 	if (state->msgid_count == 0)
 		return 0;
 
 	*state->error = 0;
 
 	struct PoEntry* current = NULL;
 	for (size_t e = state->msgid_number; e < state->msgid_count; e++)
 	{
 		current = state->entries + e;
 		if (current->flags & FL_FUZZY)
 		{
 			int saved_show_edit = state->show_edit;
 			if (saved_show_edit)
 			{
 				if (state->dirty)
 					save_msgstr(state);
 				else /* No need to call cancel_msgstr */
 					state->dirty = state->dirty_before_edit;
 			}
 
 			goto_msgid(state, e + 1);
 
 			if (saved_show_edit)
 			{
 				state->msgstr_index = 0;
 				show_edit(state);
 			}
 
 			return 0;
 		}
 	}
 	return 0;
 }
 
 int
 next_match(struct DrawState* state)
 {
 	if (state->msgid_count == 0 || !state->search || !*state->search)
 		return 0;
 
 	*state->error		= 0;
 	struct PoEntry* current = NULL;
 	for (size_t e = state->msgid_number; e < state->real_msgid_count; e++)
 	{
 		current = state->entries + e;
 		if (current->obsolete)
 			continue;
 		if ((current->msgid && *current->msgid
 			    && u32_strstr(current->msgid, state->search))
 			|| (current->msgstr && *current->msgstr
 				&& **current->msgstr
 				&& u32_strstr(*current->msgstr, state->search)))
 		{
 			goto_msgid(state, e + 1);
 			return 0;
 		}
 	}
 	return 0;
 }
 
 int
 next_plural(struct DrawState* state)
 {
 	struct PoEntry* current = NULL;
 	if (state->edit_info_focused)
 		return 1;
 	current = &state->entries[state->msgid_number - 1];
 	save_msgstr(state);
 	if (state->msgstr_index + 1 < current->msgstr_count)
 		state->msgstr_index++;
 	show_edit(state);
 	return 0;
 }
 
 int
 next_untranslated(struct DrawState* state)
 {
 	if (state->msgid_count == 0)
 		return 0;
 
 	*state->error = 0;
 
 	struct PoEntry* current = NULL;
 	for (size_t e = state->msgid_number; e < state->msgid_count; e++)
 	{
 		current = state->entries + e;
 		if (!current->msgstr || !*current->msgstr
 			|| u32_strlen(*current->msgstr) == 0)
 		{
 			int saved_show_edit = state->show_edit;
 			if (saved_show_edit)
 			{
 				if (state->dirty)
 					save_msgstr(state);
 				else /* No need to call cancel_msgstr */
 					state->dirty = state->dirty_before_edit;
 			}
 
 			goto_msgid(state, e + 1);
 
 			if (saved_show_edit)
 			{
 				state->msgstr_index = 0;
 				show_edit(state);
 			}
 
 			return 0;
 		}
 	}
 	return 0;
 }
 
 int
 paste_paste_buffer_to_input(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 		return 1;
 
 	if (!state->in_prompt && *state->input_buffer->text)
 	{
 		state->in_prompt = 1;
 		STRLCPY(prompt_overwrite, state->prompt, MAXBUFLINE);
 		state->prompt_callback = overwrite_paste_callback;
 		return 0;
 	}
 
 	if (state->msgid_number == 1)
 	{
 		STRLCPY(errors[ERR_ILLEGAL_ON_FIRST], state->error, MAXBUFLINE);
 		return 0;
 	}
 
 	size_t lines_to_init	  = 0;
 	size_t lines_to_free	  = 0;
 	struct BufferLine* pinput = NULL;
 	struct BufferLine* newbuf = NULL;
 	struct BufferLine* ppaste = NULL;
 
 	if (!state->paste_buffer || !(*state->paste_buffer).text
 		|| !*(*state->paste_buffer).text)
 	{
 		/* leave one row */
 		for (size_t i = 1; i < state->input_rows_count; i++)
 			free_bufferline(state->input_buffer + i);
 		state->input_buffer		= realloc(state->input_buffer,
 				    sizeof(struct BufferLine));
 		*(state->input_buffer->text)	= 0;
 		state->input_column		= 0;
 		state->input_display_column	= 0;
 		state->input_first_shown_column = 0;
 		state->input_first_shown_row	= 0;
 		state->input_row		= 0;
 		state->input_rows_count		= 1;
 		state->dirty			= 1;
 		return 0;
 	}
 
 	lines_to_init = state->input_rows_count < state->paste_rows_count
 		? state->paste_rows_count - state->input_rows_count
 		: 0;
 	lines_to_free = state->input_rows_count > state->paste_rows_count
 		? state->input_rows_count - state->paste_rows_count
 		: 0;
 
 	for (size_t i = 0; i < lines_to_free; i++)
 		free_bufferline(
 			state->input_buffer + state->input_rows_count - i - 1);
 	newbuf = realloc(state->input_buffer,
 		state->paste_rows_count * sizeof(struct BufferLine));
 	ppaste = state->paste_buffer;
 
 	if (!newbuf)
 		return 0;
 
 	for (size_t i = 0; i < lines_to_init; i++)
 	{
 		pinput = newbuf + state->paste_rows_count - 1 - i;
 		init_bufferline(pinput);
 		uint32_t* newtext = calloc(MAXBUFLINE, sizeof(uint32_t));
 		if (!newtext)
 			return 0;
 		pinput->text = newtext;
 	}
 
 	if (ppaste)
 		for (size_t i = 0; i < state->paste_rows_count; i++)
 		{
 			pinput = newbuf + i;
 			u32_strncpy(pinput->text, ppaste->text,
 				MIN(ppaste->length + 1, MAXBUFLINE));
 			pinput->length = ppaste->length;
 			ppaste++;
 		}
 
 	state->input_rows_count = state->paste_rows_count;
 	state->input_buffer	= newbuf;
 	state->dirty		= 1;
 
 	return 0;
 }
 
 int
 prev_match(struct DrawState* state)
 {
 	if (state->msgid_count == 0 || !state->search || !*state->search)
 		return 0;
 
 	*state->error		= 0;
 	struct PoEntry* current = NULL;
 	for (size_t e = state->msgid_number - 1; e > 0; e--)
 	{
 		current = state->entries + e - 1;
 		if ((current->msgid && *current->msgid
 			    && u32_strstr(current->msgid, state->search))
 			|| (current->msgstr && *current->msgstr
 				&& **current->msgstr
 				&& u32_strstr(*current->msgstr, state->search)))
 		{
 			goto_msgid(state, e);
 			return 0;
 		}
 	}
 	return 0;
 }
 
 int
 prev_plural(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 		return 1;
 	save_msgstr(state);
 	if (state->msgstr_index > 0)
 		state->msgstr_index--;
 	show_edit(state);
 	return 0;
 }
 
 int
 save_msgstr(struct DrawState* state)
 {
 	uint32_t* to_save	= NULL;
 	size_t to_save_size	= 0;
 	struct PoEntry* current = NULL;
 
 	state->show_edit	 = 0;
 	state->edit_info_focused = 0;
 
 	if (state->input_buffer)
 	{
 		to_save_size = state->input_rows_count * MAXMSGLINE;
 		to_save	     = calloc(to_save_size, sizeof(uint32_t));
 		if (!to_save)
 		{
 			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
 				MAXBUFLINE);
 			return 0;
 		}
 		struct BufferLine* pinput_buffer = NULL;
 		for (size_t i = 0; i < state->input_rows_count; i++)
 		{
 			pinput_buffer = state->input_buffer + i;
 			if (i == 0)
 				u32_strncpy(to_save, pinput_buffer->text,
 					to_save_size * sizeof(uint32_t));
 			else
 			{
 				u32_strncat(to_save, (uint32_t*)L"\\n",
 					to_save_size * sizeof(uint32_t));
 				u32_strncat(to_save, pinput_buffer->text,
 					to_save_size * sizeof(uint32_t));
 			}
 			free_bufferline(pinput_buffer);
 		}
 	}
 	free(state->input_buffer);
 	state->input_buffer	= NULL;
 	state->input_rows_count = 0;
 	for (size_t i = 0; i < state->info_rows_count; i++)
 		free_bufferline(state->info_buffer + i);
 	free(state->info_buffer);
 	state->dirty	       = (state->dirty_before_edit || state->dirty);
 	state->info_rows_count = 0;
 	state->info_buffer     = NULL;
 	u32_encode_tabs(to_save, to_save_size * sizeof(uint32_t));
 	current = &state->entries[state->msgid_number - 1];
 	u32_match_msgid_ending(current->msgid, to_save,
 		to_save_size * sizeof(uint32_t));
 	u32_set_msgstr(current, to_save, state->msgstr_index, 0, state);
 	update_warning(current->msgid, to_save, &current->warning);
 	state->input_changed_fuzzy = UNCHANGED;
 
 	tb_hide_cursor();
 	free(to_save);
 	return 0;
 }
 
 int
 show_edit(struct DrawState* state)
 {
 	if (!load_msgstr(state) || !load_info(state))
 	{
 		STRLCPY(errors[ERR_CANT_ALLOC], state->error, MAXBUFLINE);
 		state->running = 0;
 		return 0;
 	}
 
 	state->dirty_before_edit	= state->dirty;
 	state->dirty			= 0;
 	state->fuzzy_before_edit	= state->fuzzy_count;
 	state->input_changed_fuzzy	= UNCHANGED;
 	state->show_edit		= 1;
 	state->input_row		= 0;
 	state->input_first_shown_row	= 0;
 	state->input_first_shown_column = 0;
 	state->info_first_shown_row	= 0;
 	state->info_first_shown_column	= 0;
 	move_start(state);
 	*state->error = 0;
 	return 0;
 }
 
 int
 show_help(struct DrawState* state)
 {
 	state->show_help = 1;
 	*state->error	 = 0;
 	return 0;
 }
 
 int
 show_search(struct DrawState* state)
 {
 	state->show_search		 = 1;
 	state->search_column		 = 0;
 	state->search_display_column	 = 0;
 	state->search_first_shown_column = 0;
 	if (!state->search)
 		state->search = calloc(MAXSEARCH, sizeof(uint32_t));
 	*state->search = 0;
 	tb_set_cursor((state->maxx - state->search_width + 2) / 2,
 		state->maxy - 1 - SEARCH_HEIGHT + 1);
 	return 0;
 }
 
 int
 toggle_fuzzy(struct DrawState* state)
 {
 	if (state->msgid_number == 1)
 	{
 		STRLCPY(errors[ERR_ILLEGAL_ON_FIRST], state->error, MAXBUFLINE);
 		return 0;
 	}
 	if (state->msgid_count > 0)
 	{
 		state->entries[state->msgid_number - 1].flags ^= FL_FUZZY;
 		if (state->entries[state->msgid_number - 1].flags & FL_FUZZY)
 		{
 			state->fuzzy_count++;
 			if (state->input_changed_fuzzy == CLEARED)
 				state->input_changed_fuzzy = UNCHANGED;
 			else
 				state->input_changed_fuzzy = SET;
 		}
 		else
 		{
 			state->fuzzy_count--;
 			if (state->input_changed_fuzzy == SET)
 				state->input_changed_fuzzy = UNCHANGED;
 			else
 				state->input_changed_fuzzy = CLEARED;
 		}
 		state->dirty = 1;
 	}
 	return 0;
 }
 
 int
 toggle_info_focused(struct DrawState* state)
 {
 	state->edit_info_focused = !state->edit_info_focused;
 	return 0;
 }
 
 int
 yank_input_to_paste_buffer(struct DrawState* state)
 {
 	if (state->edit_info_focused)
 		return 1;
 
 	if (state->msgid_number == 1)
 	{
 		STRLCPY(errors[ERR_ILLEGAL_ON_FIRST], state->error, MAXBUFLINE);
 		return 0;
 	}
 
 	size_t lines_to_init	  = 0;
 	size_t lines_to_free	  = 0;
 	struct BufferLine* ppaste = NULL;
 	struct BufferLine* newbuf = NULL;
 	struct BufferLine* pinput = NULL;
 
 	if (!state->input_buffer || !(*state->input_buffer).text
 		|| !*(*state->input_buffer).text)
 	{
 		for (size_t i = 0; i < state->paste_rows_count; i++)
 			free_bufferline(state->paste_buffer + i);
 		free(state->paste_buffer);
 		state->paste_buffer	= NULL;
 		state->paste_rows_count = 0;
 		return 0;
 	}
 
 	lines_to_init = state->paste_rows_count < state->input_rows_count
 		? state->input_rows_count - state->paste_rows_count
 		: 0;
 	lines_to_free = state->paste_rows_count > state->input_rows_count
 		? state->paste_rows_count - state->input_rows_count
 		: 0;
 
 	for (size_t i = 0; i < lines_to_free; i++)
 		free_bufferline(
 			state->paste_buffer + state->paste_rows_count - i - 1);
 	if (!state->paste_buffer)
 		newbuf = calloc(state->input_rows_count,
 			sizeof(struct BufferLine));
 	else
 		newbuf = realloc(state->paste_buffer,
 			state->input_rows_count * sizeof(struct BufferLine));
 	pinput = state->input_buffer;
 
 	if (!newbuf)
 		return 0;
 
 	for (size_t i = 0; i < lines_to_init; i++)
 	{
 		ppaste = newbuf + state->input_rows_count - 1 - i;
 		init_bufferline(ppaste);
 		uint32_t* newtext = calloc(MAXBUFLINE, sizeof(uint32_t));
 		if (!newtext)
 			return 0;
 		ppaste->text = newtext;
 	}
 
 	if (pinput)
 		for (size_t i = 0; i < state->input_rows_count; i++)
 		{
 			ppaste = newbuf + i;
 			u32_strncpy(ppaste->text, pinput->text,
 				MIN(pinput->length + 1, MAXBUFLINE));
 			ppaste->length = pinput->length;
 			pinput++;
 		}
 
 	state->paste_rows_count = state->input_rows_count;
 	state->paste_buffer	= newbuf;
 
 	return 0;
 }
 
 int
 write_file(struct DrawState* state)
 {
 	int result = save_file(state->entries, state->real_msgid_count,
 		state->filename, state->nplurals);
 	switch (result)
 	{
 	case SAVE_ERR_CANT_ALLOC:
 		STRLCPY(errors[ERR_CANT_ALLOC], state->error, MAXBUFLINE);
 		state->running = 0;
 		break;
 	case SAVE_ERR_CANT_OPEN_FILE:
 		STRLCPY(errors[ERR_CANT_SAVE], state->error, MAXBUFLINE);
 		state->running = 0;
 		break;
 	case SAVE_ERR_CANT_MOVE_FILE:
 		STRLCPY(strerror(errno), state->error, MAXBUFLINE);
 		state->running = 0;
 		break;
 	default:
 		*state->error = 0;
 		state->dirty  = 0;
 	}
 	return 0;
 }
 
 int
 main(int argc, char** argv)
 {
 	struct tb_event ev;
 	char error[MAXBUFLINE];
 	char prompt[MAXBUFLINE];
 	struct DrawState state;
 	char filename[MAXPATH];
 	int recalculate_size = 1;
 	struct stat st;
 	long lineno;
 	long col;
 	int result;
 	int dir_access;
 	int dir_access_errno;
 	char* dir = NULL;
 
 	*error	  = 0;
 	*prompt	  = 0;
 	*filename = 0;
 
 #ifdef __OpenBSD__
 	if (pledge("stdio tty unveil rpath wpath cpath fattr", NULL) < 0)
 	{
 		perror(PROGRAMNAME ": pledge");
 		exit(1);
 	}
 #endif
 	if (argc == 1)
 		return print_error(1, "No filename given");
 
 	if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))
 	{
 		printf("Usage:\t%s -h | --help | -V | --full-version | -v |"
 		       " --version\n"
 		       "\t%s filename.po\n",
 			PROGRAMNAME, PROGRAMNAME);
 		return 0;
 	}
 	else if (!strcmp(argv[1], "-v") || !strcmp(argv[1], "--version"))
 	{
 		printf("%s %s, committed on %s\n", PROGRAMNAME, VERSION, DATE);
 		return 0;
 	}
 	else if (!strcmp(argv[1], "-V") || !strcmp(argv[1], "--full-version"))
 	{
 		printf("%s %s, committed on %s\n", PROGRAMNAME, VERSION, DATE);
 		puts(COPYRIGHT);
 		printf("Features set in config.h:\n");
 #ifdef CREATE_BACKUPS
 		printf("  CREATE_BACKUPS:\tset\n");
 #else
 		printf("  CREATE_BACKUPS:\tunset\n");
 #endif
 #ifdef MATCH_MSGSTR_ENDING
 		printf("  MATCH_MSGSTR_ENDING:\tset\n");
 #else
 		printf("  MATCH_MSGSTR_ENDING:\tunset\n");
 #endif
 #ifdef PLURAL_STRING
 		printf("  PLURAL_STRING:\t\"%s\"\n", PLURAL_STRING);
 #else
 		printf("  PLURAL_STRING:\tunset\n");
 #endif
 		printf("  SAVE_WRAP_WIDTH:\t%d\n", SAVE_WRAP_WIDTH);
 		printf("  WRAP_FIRST_MSGSTR:\t%d\n", WRAP_FIRST_MSGSTR);
 		printf("  WARN_COUNT_DOTS:\t%d\n", WARN_COUNT_DOTS);
 		return 0;
 	}
 	else
 	{
 		strncpy(filename, argv[1], MAXPATH - 1);
 		filename[MAXPATH - 1] = 0;
 		if (!*filename)
 			print_error(EINVAL, "No filename given");
 	}
 
 	init_drawstate(&state, error, filename, prompt);
 
 	if (stat(filename, &st) == -1 || access(filename, R_OK | W_OK) == -1)
 		goto file_error;
 
 	if (!S_ISREG(st.st_mode))
 	{
 		result = print_error(EINVAL, "Is not a regular file");
 		goto general_error;
 	}
 
 #ifdef __OpenBSD__
 	if (unveil(state.filename, "rwc") < 0)
 	{
 		perror(PROGRAMNAME ": unveil");
 		exit(1);
 	}
 #endif
 
 	dir = dirname(state.filename);
 #ifdef __OpenBSD__
 	if (unveil(dir, "rwc") < 0)
 	{
 		perror(PROGRAMNAME ": unveil");
 		exit(1);
 	}
 #endif
 #ifdef CREATE_BACKUPS
 	errno = 0;
 	if (lstat(state.filename, &st) != -1)
 	{
 		if (S_ISLNK(st.st_mode))
 		{
 			if (!(state.real_filename = calloc(MAXPATH, 1)))
 				return print_error(1,
 					"Allocation failed (out of memory?)");
 			state.rfn_len = readlink(state.filename,
 				state.real_filename, MAXPATH);
 			if (state.rfn_len == -1)
 				goto file_error;
 			state.real_filename[state.rfn_len] = 0;
 #ifdef __OpenBSD__
 			if (unveil(state.real_filename, "rwc") < 0)
 			{
 				perror(PROGRAMNAME ": unveil");
 				exit(1);
 			}
 #endif
 			if (stat(state.real_filename, &st) == -1)
 				goto file_error;
 		}
 		if (!(state.backup_filename = calloc(MAXPATH, 1)))
 		{
 			free(state.real_filename);
 			return print_error(1,
 				"Allocation failed (out of memory?)");
 		}
 
 		/* Backup filename is the target file + suffix if the file to
 		 * write is a symlink, otherwise file + suffix */
 		STRLCPY(state.rfn_len > 0 ? state.real_filename : state.filename,
 			state.backup_filename, MAXPATH);
 		STRLCAT(backup_suffix, state.backup_filename, MAXPATH);
 #ifdef __OpenBSD__
 		if (unveil(state.backup_filename, "rwc") < 0)
 		{
 			perror(PROGRAMNAME ": unveil");
 			exit(1);
 		}
 #endif
 	}
 	else
 		goto file_error;
 #endif /* CREATE_BACKUPS */
 
 	if (state.rfn_len > 0)
 	{
 		dir = dirname(state.real_filename);
 #ifdef __OpenBSD__
 		if (unveil(dir, "rwc") < 0)
 		{
 			perror(PROGRAMNAME ": unveil");
 			exit(1);
 		}
 #endif
 	}
 
 	dir_access	 = access(dir, W_OK | X_OK);
 	dir_access_errno = errno;
 #ifdef BACKUP_FAIL_OK
 	state.backup_possible = dir_access != -1;
 #else  /* !BACKUP_FAIL_OK */
 	if (dir_access == -1)
 	{
 		errno = dir_access_errno;
 		goto file_error;
 	}
 #endif /* BACKUP_FAIL_OK */
 	if (stat(state.filename, &st) == -1)
 	{
 		errno = dir_access_errno;
 		goto file_error;
 	}
 
 	if (!S_ISREG(st.st_mode))
 	{
 		result = print_error(EINVAL, "Is not a regular file");
 		goto general_error;
 	}
 
 #ifdef __OpenBSD__
 	if (unveil(NULL, NULL) < 0)
 	{
 		perror(PROGRAMNAME ": unveil");
 		exit(1);
 	}
 #endif
 
 	if (access(state.filename, F_OK | R_OK | W_OK) == -1)
 		goto file_error;
 
 	if (state.rfn_len > 0
 		&& access(state.real_filename, F_OK | R_OK | W_OK) == -1)
 		goto file_error;
 
 	lineno = 1;
 	col    = 1;
 	result = load_file(&state, &lineno, &col);
 	switch (result)
 	{
 	case LOAD_ERR_CANT_ALLOC:
 	case LOAD_ERR_P_ALLOC:
 		(void)print_error(result, "Allocation failed (out of memory?)");
 		goto general_error;
 	case LOAD_ERR_CANT_OPEN_FILE:
 		(void)print_error(result, "Cannot open file `%s'", filename);
 		goto general_error;
 	case LOAD_ERR_NOT_PO_FILE:
 		(void)print_error(result, "Not a .po file `%s'", filename);
 		goto general_error;
 	case LOAD_ERR_P_INVAL:
 		(void)print_error(result, "Invalid value");
 		goto general_error;
 	case LOAD_ERR_P_SYNTAX:
 		(void)print_error(result, "%s:%ld:%ld: Syntax error", filename,
 			lineno, col);
 		goto general_error;
 	case LOAD_ERR_NONE:
 		if (*error)
 		{
 			result = print_error(1, error);
 			goto general_error;
 		}
 		break;
 	default:
 		result = print_error(1, "Unknown error (%d)", result);
 		goto general_error;
 	}
 	state.msgid_number	= state.msgid_count > 0 ? 1 : 0;
 	state.first_shown_msgid = state.msgid_number;
 	goto init_termbox;
 
 file_error:
 	result = errno;
 	perror(PROGRAMNAME);
 	/* FALLTHROUGH */
 
 general_error:
 	free(state.real_filename);
 	free(state.backup_filename);
 	return result;
 
 init_termbox:
 	tb_init();
 	*error	   = 0;
 	state.maxx = 0;
 
 	while (state.running)
 	{
 		tb_clear();
 
 		if (recalculate_size)
 		{
 			state.maxx	   = tb_width();
 			state.help_width   = calculate_help_width(&state);
 			state.edit_width   = calculate_edit_width(&state);
 			state.search_width = calculate_search_width(&state);
 			recalculate_size   = 0;
 		}
 		state.maxy = tb_height();
 
 		if (!draw(&state))
 			STRLCPY(errors[ERR_CANT_ALLOC], state.error, MAXBUFLINE);
 		tb_present();
 		result = tb_poll_event(&ev);
 		if (result == TB_OK && ev.type == TB_EVENT_RESIZE)
 			recalculate_size = 1;
 		else if (result == TB_OK && ev.type == TB_EVENT_KEY)
 			handle_key_event(&ev, &state);
 	}
 	tb_shutdown();
 	if (state.error && *state.error)
 		return print_error(1, state.error);
 
 	free_drawstate(&state);
 	return 0;
 }