poe

draw.c (28152B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2021-2026  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "draw.h"
 #include "config.h"
 #include "limit.h"
 #include "po.h"
 #include "util.h"
 #include "version.h"
 
 /* clang-format off */
 static const char* help_title = "Main view help";
 static const char* help[]     = {
 	"Esc         - Close dialog, clear error",
 	"Enter       - Edit entry", 
 	"H   or F1   - Show this screen",
 	"/   or F7   - Incremental search (end = Enter)",
 	"n   or F3   - Find next",
 	"N   or F4   - Find previous",
 	"u   or F8   - Go to next untranslated entry",
 	"f   or F9   - Go to next fuzzy entry",
 	"w   or C-S  - Save file (with backup)",
 	"g   or Home - Go to first entry",
 	"C-B or PgUp - Go to previous page",
 	"k   or \u2191    - Go to previous entry",
 	"j   or \u2193    - Go to next entry",
 	"C-F or PgDn - Go to next page",
 	"G   or End  - Go to last entry",
 	"z   or C-Z  - Toggle fuzzy flag",
 	"q   or C-Q  - Quit",
 	"",
 	"See the manual (man poe) for full help."};
 static const char* editbox_title = "Edit translation";
 const char* errors[]	       = {
 	[ERR_NO_CL_ARG]	       = "No filename given",
 	[ERR_NO_CL_ARG_PARAM]  = "Option requires an argument: %s",
 	[ERR_BAD_CL_ARG]       = "Invalid argument: %s",
 	[ERR_NOTPO_FILE]       = "Not a PO file",
 	[ERR_NOTREG_FILE]      = "'%s' is not a regular file",
 	[ERR_TB_ERROR]	       = "termbox error",
 	[ERR_UNKNOWN_KEY]      = "Unknown key (press F1 for help)",
 	[ERR_UNKNOWN_KEY_HELP] = "Unknown key (press H or F1 for help)",
 	[ERR_EXIT_KEY]	       = "Press q or C-Q to quit",
 	[ERR_DLG_OPEN]	       = "Press Esc to close dialog or q/C-Q to quit",
 	[ERR_DLG_OPEN_QUIT]    = "Press Esc to close dialog first",
 	[ERR_DLG_FOCUS_EDIT]   = "Switch to edit box with F6 or press Esc",
 	[ERR_CANT_ALLOC]       = "Memory allocation failed",
 	[ERR_ILLEGAL_ON_FIRST] = "Not allowed on first entry",
 	[ERR_SYNTAX]	       = "%s:%ld:%ld: Syntax error",
 	[ERR_NO_PLURAL_FORMS]  = "No Plural-Forms (add manually)",
 	[ERR_BAD_NPLURALS]     = "Cannot read nplurals",
 	[ERR_ERRNO_SET]	       = "System call/library function error"};
 const char* actions[]  = {
 	[ACT_WRITING]  = "Writing...",
 	[ACT_READING]  = "Reading..."
 };
 const char* flag_strings[]	= {
 	[FL_C_FORMAT]		= "c-format",
 	[FL_NO_C_FORMAT]	= "no-c-format",
 	[FL_FUZZY]		= "fuzzy"};
 const char* first_entry_msgid	= "*** SPECIAL: file info ***";
 const char* prompt_dirty	= "File changed, save [y/n/ESC]?";
 const char* prompt_edit_dirty	= "Entry changed, save [y/n/ESC]?";
 const char* prompt_overwrite	= "Not empty, overwrite? [y/n/ESC]?";
 /* clang-format on */
 
 extern int print_error(const int code, const char* msg, ...);
 
 void
 assign_coord(struct Coord* dest, const struct Coord src)
 {
 	init_coord(dest, src.col, src.row);
 }
 
 /* Calculates buffer length from a display length.
  * max_index = the display index up to which the length is calculated
  */
 ssize_t
 buffer_length(uint32_t* buffer, const ssize_t max_index)
 {
 	uint32_t* pbuf = buffer;
 	ssize_t i;
 	ssize_t len = 0;
 	int w;
 
 	if (!pbuf)
 		return 0;
 
 	for (i = 0; *pbuf && len < max_index; i++)
 	{
 		pbuf = &buffer[i];
 		if (*pbuf == '\t')
 			len += MIN(TAB_SIZE - (len % TAB_SIZE), max_index - len);
 		else
 		{
 			w = wcwidth((wchar_t)*pbuf);
 			if (w > 0)
 				len += MIN(w, max_index - len);
 		}
 	}
 	return i;
 }
 
 int
 calculate_edit_width(const struct DrawState* state)
 {
 	assert(state != NULL);
 	return state->maxx > EDIT_WIDTH + 3 ? EDIT_WIDTH : state->maxx - 3;
 }
 
 int
 calculate_help_width(const struct DrawState* state)
 {
 	assert(state != NULL);
 	return state->maxx > HELP_WIDTH + 2 ? HELP_WIDTH : state->maxx - 2;
 }
 
 int
 calculate_search_width(const struct DrawState* state)
 {
 	assert(state != NULL);
 	return state->maxx > SEARCH_WIDTH + 2 ? SEARCH_WIDTH : state->maxx - 2;
 }
 
 /* Calculates display length of an input buffer line.
  * max_index = the input index up to which the length is calculated
  */
 ssize_t
 display_length(uint32_t* buffer, const ssize_t max_index)
 {
 	uint32_t* pbuf = buffer;
 	ssize_t len    = 0;
 	int w;
 
 	assert(buffer != NULL);
 	for (ssize_t i = 0; *pbuf && i < max_index; i++)
 	{
 		pbuf = &buffer[i];
 		if (*pbuf == '\t')
 			len += TAB_SIZE - (len % TAB_SIZE);
 		else if (!*pbuf)
 			len++;
 		else
 		{
 			w = wcwidth((wchar_t)*pbuf);
 			if (w > 0)
 				len += w;
 		}
 	}
 
 	return len;
 }
 
 int
 draw(const struct DrawState* state)
 {
 	assert(state != NULL);
 	if (draw_list_visible(state))
 		return 1;
 	if (state->show_help)
 		if (draw_help(state))
 			return 1;
 	if (state->show_edit)
 		if (draw_editbox(state))
 			return 1;
 	if (state->show_search)
 		if (draw_search(state))
 			return 1;
 	if (draw_status(state))
 		return 1;
 	return 0;
 }
 
 void
 draw_box(const int startx, const int endx, const int starty, const int endy,
 	const uint16_t fg, const uint16_t bg)
 {
 	int x, y;
 
 	tb_set_cell(startx, starty, BORDER_NW, fg, bg);
 	for (x = startx + 1; x < endx - 1; x++)
 		tb_set_cell(x, starty, BORDER_HOR, fg, bg);
 	tb_set_cell(endx - 1, starty, BORDER_NE, fg, bg);
 
 	for (y = starty + 1; y < endy - 2; y++)
 	{
 		tb_set_cell(startx, y, BORDER_VER, fg, bg);
 		for (x = startx + 1; x < endx - 1; x++)
 			tb_set_cell(x, y, ' ', fg, bg);
 		tb_set_cell(endx - 1, y, BORDER_VER, fg, bg);
 		tb_set_cell(endx, y, ' ', colors[C_SHADOW].fg,
 			colors[C_SHADOW].bg);
 	}
 
 	tb_set_cell(startx, endy - 2, BORDER_SW, fg, bg);
 	for (x = startx + 1; x < endx - 1; x++)
 		tb_set_cell(x, endy - 2, BORDER_HOR, fg, bg);
 	tb_set_cell(endx - 1, endy - 2, BORDER_SE, fg, bg);
 	tb_set_cell(endx, endy - 2, ' ', colors[C_SHADOW].fg,
 		colors[C_SHADOW].bg);
 
 	for (x = startx + 1; x < endx + 1; x++)
 		tb_set_cell(x, endy - 1, ' ', colors[C_SHADOW].fg,
 			colors[C_SHADOW].bg);
 }
 
 int
 draw_help(const struct DrawState* state)
 {
 	int maxx, maxy;
 	int row = 0;
 	int startx, endx, starty, endy;
 	int w, h;
 
 	assert(state != NULL);
 	w    = state->help_width;
 	h    = HELP_HEIGHT;
 	maxx = state->maxx;
 	maxy = state->maxy;
 
 	startx = w > maxx ? 0 : (maxx - w) / 2;
 	endx   = w > maxx ? maxx - 1 : startx + w;
 
 	starty = h > maxy - 1 ? 0 : (maxy - h) / 2;
 	endy   = h > maxy - 1 ? maxy - 2 : starty + h;
 
 	draw_box(startx, endx, starty, endy, colors[C_DLG].fg, colors[C_DLG].bg);
 	if (draw_string(startx, starty, colors[C_TITLE].fg, colors[C_TITLE].bg,
 		    help_title, strlen(help_title) + 2, w, 1, 1, CENTER, 0, 0,
 		    NULL, 0, 0))
 		return 1;
 	while ((size_t)row < LEN(help))
 	{
 		if (draw_string(startx + 1, starty + 1 + row, colors[C_DLG].fg,
 			    colors[C_DLG].bg, help[row], w - 2, w - 2, 1, 1,
 			    LEFT, 0, 1, NULL, 0, 0))
 			return 1;
 		row++;
 	}
 	tb_hide_cursor();
 	return 0;
 }
 
 int
 draw_editbox(const struct DrawState* state)
 {
 	struct PoEntry* entry;
 	struct BufferLine* curline;
 	char flags_buf[MAXFLAGSBUF];
 	char sbuf[LINE_DEFAULT];
 	ssize_t dlen, i;
 	uint16_t fg, bg;
 	int maxx, maxy;
 	int startx, endx, starty, endy;
 	int w, h;
 
 	assert(state != NULL);
 	w     = state->edit_width;
 	h     = EDIT_HEIGHT;
 	maxx  = state->maxx;
 	maxy  = state->maxy;
 	entry = state->entries + state->msgid_number - 1;
 
 	format_flags(flags_buf, MAXFLAGSBUF, entry, 1);
 
 	startx = w > maxx ? 0 : (maxx - w) / 2;
 	endx   = w > maxx ? maxx - 1 : startx + w;
 
 	starty = h > maxy - 1 ? 0 : (maxy - h) / 2;
 	endy   = h > maxy - 1 ? maxy - 2 : starty + h;
 
 	draw_box(startx, endx, starty, endy, colors[C_DLG].fg, colors[C_DLG].bg);
 	if (draw_string(startx + 1, starty, colors[C_TITLE].fg,
 		    colors[C_TITLE].bg, editbox_title, strlen(editbox_title) + 2,
 		    w - 2, 1, 1, CENTER, 0, 0, NULL, 0, 0))
 		return 1;
 
 	fg = state->edit_info_focused ? colors[C_EDIT_MSGID_FOCUS].fg
 				      : colors[C_EDIT_MSGID].fg;
 	bg = state->edit_info_focused ? colors[C_EDIT_MSGID_FOCUS].bg
 				      : colors[C_EDIT_MSGID].bg;
 
 	draw_rect(startx + 1, endx - 1, starty + 1, endy - h / 2 - 1, fg, bg);
 	for (i = 0; i < (h - 3) / 2 + 1
 		&& (ssize_t)state->info_first_shown.row + i
 			< state->info_rows_count;
 		i++)
 	{
 		curline = &state->info_buffer[state->info_first_shown.row + i];
 		if (!curline || !curline->text)
 			return 1;
 		dlen = display_length(curline->text, curline->length);
 		if (dlen > state->info_first_shown.col)
 			u32_draw_string(startx + 1, starty + 1 + i,
 				curline->fg == 0 ? fg : curline->fg,
 				curline->bg == 0 ? bg : curline->bg,
 				curline->text, w - 2, w - 2, 1, 1, LEFT,
 				state->info_first_shown.col, 1, NULL, 0, 0);
 	}
 
 	if (state->info_first_shown.row > 0)
 		tb_set_cell(endx - 2, starty + 1, ARROW_UP, fg, bg);
 	if (state->info_first_shown.row + (h - 3) / 2 < state->info_rows_count)
 		tb_set_cell(endx - 2, starty + (h - 3) / 2, ARROW_DOWN, fg, bg);
 
 	fg = state->edit_info_focused ? colors[C_EDIT_MSGSTR].fg
 				      : colors[C_EDIT_MSGSTR_FOCUS].fg;
 	bg = state->edit_info_focused ? colors[C_EDIT_MSGSTR].bg
 				      : colors[C_EDIT_MSGSTR_FOCUS].bg;
 
 	draw_rect(startx + 1, endx - 1, endy - h / 2 - 1, endy - 2, fg, bg);
 	for (i = 0; i < (h - 3) / 2 + 1
 		&& (ssize_t)state->input_first_shown.row + i
 			< state->input_rows_count;
 		i++)
 	{
 		curline = &state->input_buffer[state->input_first_shown.row + i];
 		if (!curline || !curline->text)
 			return 1;
 		dlen = display_length(curline->text, curline->length);
 		if (dlen > state->input_first_shown.col)
 			u32_draw_string(startx + 1, endy - h / 2 - 1 + i, fg,
 				bg, curline->text, w - 2, w - 2, 1, 1, LEFT,
 				state->input_first_shown.col, 1, NULL, 0, 0);
 	}
 
 	if (state->edit_info_focused)
 		tb_hide_cursor();
 	else
 		tb_set_cursor(startx + 2 + state->input_display_column
 				- state->input_first_shown.col,
 			endy - h / 2 - 1 + state->coord.row
 				- state->input_first_shown.row);
 
 	if (entry->msgstr_count > 1)
 		snprintf(sbuf, LINE_DEFAULT,
 			"%d[%d]:%d[%d]/%ld (plural: %d/%d)",
 			state->input_display_column,
 			state->input_first_shown.col, state->coord.row,
 			state->input_first_shown.row, state->input_rows_count,
 			state->msgstr_index + 1, entry->msgstr_count);
 	else
 		snprintf(sbuf, LINE_DEFAULT, "%d[%d]:%d[%d]/%ld",
 			state->input_display_column,
 			state->input_first_shown.col, state->coord.row,
 			state->input_first_shown.row, state->input_rows_count);
 	draw_string(startx + 1, endy - 2, colors[C_DLG].fg, colors[C_DLG].bg,
 		sbuf, strlen(sbuf) + 2, w - 2, 1, 1, LEFT, 0, 0, NULL, 0, 0);
 	if (entry->flags != FL_NONE)
 		if (draw_string(endx - MAXFLAGSBUF - 4 - 5, endy - 2,
 			    colors[C_DLG].fg, colors[C_DLG].bg, flags_buf,
 			    MAXFLAGSBUF + 4 - 1, MAXFLAGSBUF + 4 - 1, 0, 0,
 			    LEFT, 0, 0, NULL, 0, 0))
 			return 1;
 	return 0;
 }
 
 int
 draw_list_visible(const struct DrawState* state)
 {
 	const struct PoEntry* current = NULL;
 	ssize_t i		      = 0;
 	int cy			      = 0;
 	int flags_len;
 	int max_screen_entries = 0;
 
 	assert(state != NULL);
 
 	if (state->msgid_count == 0)
 		return 0;
 
 	max_screen_entries = state->maxy - 1;
 	i		   = state->first_shown_msgid;
 
 	while (i <= state->real_msgid_count && cy < max_screen_entries)
 	{
 		char flags_buf[MAXFLAGSBUF];
 		int sel;
 
 		current = state->entries + i - 1;
 		if (current->obsolete)
 		{
 			i++;
 			continue;
 		}
 
 		sel = i == state->msgid_number;
 
 		if (sel)
 			draw_rect(0, state->maxx - 1, cy, cy + 1,
 				colors[C_LIST_SEL].fg, colors[C_LIST_SEL].bg);
 
 		format_flags(flags_buf, MAXFLAGSBUF, current, 0);
 		flags_len = strlen(flags_buf) + 1;
 
 		if (draw_string(0, cy,
 			    sel ? colors[C_LIST_FLAGS_SEL].fg
 				: colors[C_LIST_FLAGS].fg,
 			    sel ? colors[C_LIST_FLAGS_SEL].bg
 				: colors[C_LIST_FLAGS].bg,
 			    flags_buf, flags_len, flags_len, 2, 0, LEFT, 0, 1,
 			    NULL, 0, 0))
 			return 1;
 		if (current->msgid)
 			u32_draw_string(flags_len, cy,
 				sel ? colors[C_LIST_MSGID_SEL].fg
 				    : colors[C_LIST_MSGID].fg,
 				sel ? colors[C_LIST_MSGID_SEL].bg
 				    : colors[C_LIST_MSGID].bg,
 				current->msgid, state->maxx / 2 - flags_len,
 				state->maxx / 2 - flags_len, 2, 0, LEFT, 0, 1,
 				state->search, colors[C_SEARCH_HL].fg,
 				colors[C_SEARCH_HL].bg);
 		else if (current == state->entries) /* special */
 			draw_string(flags_len, cy,
 				sel ? colors[C_LIST_MSGID_SPECIAL_SEL].fg
 				    : colors[C_LIST_MSGID_SPECIAL].fg,
 				sel ? colors[C_LIST_MSGID_SPECIAL_SEL].bg
 				    : colors[C_LIST_MSGID_SPECIAL].bg,
 				first_entry_msgid, state->maxx / 2 - flags_len,
 				state->maxx / 2 - flags_len, 2, 0, LEFT, 0, 1,
 				NULL, 0, 0);
 
 		/* don't use msgstr_index as then the entire list will shift
 		 * when changing currently displayed plural form msgstr in an
 		 * edit box */
 		if (current->msgstr && current->msgstr_count > 0)
 			u32_draw_string(state->maxx / 2, cy,
 				current->warning
 					? (sel ? colors[C_LIST_MSGSTR_SEL_WARN].fg
 					       : colors[C_LIST_MSGSTR_WARN].fg)
 					: (sel ? colors[C_LIST_MSGSTR_SEL].fg
 					       : colors[C_LIST_MSGSTR].fg),
 				current->warning
 					? (sel ? colors[C_LIST_MSGSTR_SEL_WARN].bg
 					       : colors[C_LIST_MSGSTR_WARN].bg)
 					: (sel ? colors[C_LIST_MSGSTR_SEL].bg
 					       : colors[C_LIST_MSGSTR].bg),
 				*(current->msgstr), state->maxx / 2,
 				state->maxx / 2, 2, 2, LEFT, 0, 1,
 				state->search, colors[C_SEARCH_HL].fg,
 				colors[C_SEARCH_HL].bg);
 		i++;
 		cy++;
 	}
 	return 0;
 }
 
 void
 draw_rect(const int startx, const int endx, const int starty, const int endy,
 	const uint16_t fg, const uint16_t bg)
 {
 	int x, y;
 	for (y = starty; y < endy; y++)
 		for (x = startx; x < endx; x++)
 			tb_set_cell(x, y, ' ', fg, bg);
 }
 
 int
 draw_search(const struct DrawState* state)
 {
 	ssize_t len;
 	ssize_t dlen = 0;
 	int maxx, maxy;
 	int startx, endx, starty, endy;
 	int w, h;
 
 	assert(state != NULL);
 	w    = state->search_width;
 	h    = SEARCH_HEIGHT;
 	maxx = state->maxx;
 	maxy = state->maxy;
 	len  = u32_strlen(state->search);
 
 	startx = w > maxx ? 0 : (maxx - w) / 2;
 	endx   = w > maxx ? maxx - 1 : startx + w;
 
 	starty = maxy - 1 - h;
 	endy   = maxy - 1;
 
 	draw_box(startx, endx, starty, endy, colors[C_SEARCH].fg,
 		colors[C_SEARCH].bg);
 	draw_rect(startx + 1, endx - 1, starty + 1, endy - 2,
 		colors[C_SEARCH_EDIT].fg, colors[C_SEARCH_EDIT].bg);
 	dlen = display_length(state->search, len);
 	if (dlen > state->search_first_shown_column)
 		u32_draw_string(startx + 1, starty + 1,
 			colors[C_SEARCH_EDIT].fg, colors[C_SEARCH_EDIT].bg,
 			state->search, w - 2, w - 2, 1, 1, LEFT,
 			state->search_first_shown_column, 1, NULL, 0, 0);
 	tb_set_cursor(startx + 2 + state->search_display_column
 			- state->search_first_shown_column,
 		starty + 1);
 	return 0;
 }
 
 int
 draw_status(const struct DrawState* state)
 {
 	const struct StatusSegment* pseg;
 	char* buf = NULL;
 	ssize_t seg_size;
 	int current_start;
 	int last, maxx;
 
 	assert(state != NULL);
 	maxx	      = state->maxx;
 	seg_size      = maxx / LEN(status_segments);
 	current_start = 0;
 	pseg	      = status_segments;
 
 	if (state->in_prompt && *state->prompt)
 	{
 		if (draw_string(0, state->maxy - 1, colors[C_PROMPT].fg,
 			    colors[C_PROMPT].bg, state->prompt,
 			    strlen(state->prompt) + 2, maxx, 1, 1, CENTER, 0, 1,
 			    NULL, 0, 0))
 			return 1;
 	}
 	else if (state->action)
 	{
 		if (draw_string(0, state->maxy - 1, colors[C_ACTION].fg,
 			    colors[C_ACTION].bg, actions[state->action],
 			    strlen(actions[state->action]) + 2, maxx, 1, 1,
 			    CENTER, 0, 1, NULL, 0, 0))
 			return 1;
 	}
 	else if (state->error)
 	{
 		if (draw_string(0, state->maxy - 1, colors[C_ERROR].fg,
 			    colors[C_ERROR].bg, errors[state->error],
 			    strlen(errors[state->error]) + 2, maxx, 1, 1,
 			    CENTER, 0, 1, NULL, 0, 0))
 			return 1;
 	}
 	else
 		while (pseg < status_segments + LEN(status_segments))
 		{
 			last = pseg - status_segments
 				== LEN(status_segments) - 1;
 			buf = calloc(limits[L_LINE_MAX], 1);
 			if (!buf)
 				return 1;
 
 			*buf = 0;
 			if (pseg->callback)
 				pseg->callback(buf, limits[L_LINE_MAX],
 					pseg->format, seg_size, state);
 			else
 				memccpy(buf, pseg->format, 0,
 					limits[L_LINE_MAX]);
 			if (pseg == status_segments + LEN(status_segments) - 1)
 				seg_size = maxx - 1 - current_start;
 			if (draw_string(current_start, state->maxy - 1,
 				    colors[pseg->color_index].fg,
 				    colors[pseg->color_index].bg, buf,
 				    MIN(seg_size, (ssize_t)(strlen(buf) + 2)),
 				    last ? seg_size + 1 : seg_size, 1, 1,
 				    pseg->alignment, 0, 1, NULL, 0, 0))
 			{
 				free(buf);
 				return 1;
 			}
 			free(buf);
 			pseg++;
 			current_start += seg_size;
 		}
 	return 0;
 }
 
 /*  mc  - (max cols) pack text and padding into this many columns
  *  fc  - (fill cols) this many columns from the left/right/center will be
  *  	  filled
  *  p_? - (padding) this many cells will be skipped from ? side
  *  ds  - (display start) string starts being displayed from this display column
  * 	  counted from the start of the string; an "entry point" joining string
  * 	  index with screen
  * fill - boolean; 1 = fill fc, 0 = don't fill fc
  * srch - search string; if empty or NULL no highlighting happens
  * sfg  - fg color of search highlght
  * sbg  - bg color of search highlight
  * */
 int
 draw_string(const int x, const int y, const uint16_t fg, const uint16_t bg,
 	const char* s, const int mc, const int fc, const int p_l, const int p_r,
 	const Alignment align, const int ds, const int fill,
 	const uint32_t* srch, const uint16_t sfg, const uint16_t sbg)
 {
 	uint32_t* us = NULL;
 	assert(s != NULL);
 	us = calloc(strlen(s) + 1, sizeof(uint32_t));
 	if (!us)
 		return 1;
 	u8_string_to_unicode(us, s, mc);
 	u32_draw_string(x, y, fg, bg, us, mc, fc, p_l, p_r, align, ds, fill,
 		srch, sfg, sbg);
 	free(us);
 	return 0;
 }
 
 void
 format_filename(char* result, ssize_t result_size, const char* format,
 	const ssize_t seg_size, const struct DrawState* state)
 {
 	char* basename	  = NULL;
 	const char* pbase = NULL;
 	int dirty;
 
 	assert((state != NULL) && (format != NULL));
 	if (!result || seg_size < 4)
 		return;
 
 	pbase	 = u8_basename(state->filename);
 	basename = strndup(pbase, strlen(pbase) + 1);
 	dirty	 = state->edit_dirty || state->dirty;
 	if ((ssize_t)(u8_strlen(basename) + 2) >= seg_size)
 	{
 		if (dirty)
 			basename[seg_size - 4] = 0;
 		else
 			basename[seg_size - 3] = 0;
 		snprintf(result, result_size, format, basename,
 			dirty ? "…*" : "…");
 	}
 	else
 		snprintf(result, result_size, format, basename,
 			dirty ? "*" : "");
 	free(basename);
 }
 
 void
 format_msgs(char* result, ssize_t result_size, const char* format,
 	const ssize_t seg_size, const struct DrawState* state)
 {
 	assert((state != NULL) && (format != NULL));
 	UNUSED(seg_size);
 	if (!result)
 		return;
 
 	snprintf(result, result_size, format,
 		state ? real_msgid_to_display_msgid(state) : 0,
 		state ? state->msgid_count : 0,
 		state ? state->untranslated_count : 0,
 		state ? state->fuzzy_count : 0,
 		state ? state->obsolete_count : 0);
 }
 
 void
 free_bufferline(struct BufferLine* bl)
 {
 	if (!bl)
 		return;
 	free(bl->text);
 	bl->text   = NULL;
 	bl->length = 0;
 	bl->fg	   = 0;
 	bl->bg	   = 0;
 }
 
 void
 free_drawstate(struct DrawState* state)
 {
 	ssize_t row = 0;
 	assert(state != NULL);
 	for (row = 0; row < state->input_rows_count; row++)
 		free_bufferline(state->input_buffer + row);
 	free(state->input_buffer);
 	for (row = 0; row < state->info_rows_count; row++)
 		free_bufferline(state->info_buffer + row);
 	free(state->info_buffer);
 	for (row = 0; row < state->real_msgid_count; row++)
 		free_po_entry(state->entries + row);
 	free(state->search);
 	free(state->entries);
 }
 
 void
 init_bufferline(struct BufferLine* bl)
 {
 	if (!bl)
 		return;
 	bl->text   = NULL;
 	bl->length = 0;
 	bl->fg	   = 0;
 	bl->bg	   = 0;
 }
 
 void
 init_coord(struct Coord* c, const int col, const int row)
 {
 	assert(c != NULL);
 	c->col = col;
 	c->row = row;
 }
 
 void
 init_drawstate(struct DrawState* state, char* filename, char* prompt)
 {
 	assert(state != NULL);
 	state->prompt		  = prompt;
 	state->filename		  = filename;
 	state->orig_real_filename = NULL;
 	state->real_filename	  = NULL;
 	state->backup_filename	  = NULL;
 	state->rfn_len		  = 0;
 	state->search		  = NULL;
 	state->error		  = ERR_NONE;
 	state->action		  = ACT_IDLE;
 	state->input_buffer	  = NULL;
 	state->buffer_size	  = 0;
 	init_coord(&state->coord, 0, 0);
 	init_coord(&state->first_shown, 0, 0);
 	init_coord(&state->input_first_shown, 0, 0);
 	state->input_rows_count	    = 0;
 	state->input_display_column = 0;
 	state->input_changed_fuzzy  = UNCHANGED;
 	state->saved_column	    = -1;
 	state->info_buffer	    = NULL;
 	init_coord(&state->info_first_shown, 0, 0);
 	state->info_rows_count		 = 0;
 	state->info_maxlen		 = 0;
 	state->edit_width		 = calculate_edit_width(state);
 	state->help_width		 = calculate_help_width(state);
 	state->search_width		 = calculate_search_width(state);
 	state->paste			 = NULL;
 	state->paste_count		 = 0;
 	state->paste_size		 = 0;
 	state->search_column		 = 0;
 	state->search_first_shown_column = 0;
 	state->search_display_column	 = 0;
 	state->entries			 = NULL;
 	state->nplurals			 = 2;
 	state->prompt_callback		 = NULL;
 	state->running			 = 1;
 	state->dirty			 = 0;
 	state->edit_dirty		 = 0;
 	state->fuzzy_before_edit	 = 0;
 	state->in_prompt		 = 0;
 	state->reshow_edit		 = 0;
 	state->show_edit		 = 0;
 	state->show_help		 = 0;
 	state->edit_info_focused	 = 0;
 	state->show_search		 = 0;
 	state->recalculate_size		 = 1;
 	state->maxx			 = 0;
 	state->maxy			 = 0;
 	state->msgid_count		 = 0;
 	state->msgid_number		 = state->msgid_count > 0 ? 1 : 0;
 	state->msgid_size		 = 0;
 	state->fuzzy_count		 = 0;
 	state->untranslated_count	 = 0;
 	state->obsolete_count		 = 0;
 	state->obsolete_at_end_count	 = 0;
 	state->real_msgid_count		 = 0;
 	state->msgstr_index		 = 0;
 	state->first_shown_msgid	 = state->msgid_number;
 	state->backup_possible		 = 1;
 }
 
 /* Calculates input length from a display length.
  * max_index = the display index up to which the length is calculated
  */
 ssize_t
 input_length(uint32_t* buffer, const ssize_t max_index)
 {
 	uint32_t* pbuf = buffer;
 	ssize_t i      = 0;
 	ssize_t len    = 0;
 
 	assert(buffer != NULL);
 	for (i = 0; *pbuf && len < max_index; i++)
 	{
 		pbuf = buffer + i;
 		if (*pbuf == '\t')
 			len += MIN(TAB_SIZE - (len % TAB_SIZE), max_index - len);
 		else
 			len++;
 	}
 
 	return i;
 }
 
 size_t
 real_msgid_to_display_msgid(const struct DrawState* state)
 {
 	struct PoEntry* current;
 	size_t ret = 1;
 
 	assert((state != NULL) && (state->entries != NULL));
 	current = state->entries;
 	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;
 }
 
 void
 recalculate_size(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->maxx	    = tb_width();
 	state->maxy	    = tb_height();
 	state->help_width   = calculate_help_width(state);
 	state->edit_width   = calculate_edit_width(state);
 	state->search_width = calculate_search_width(state);
 }
 
 /*  mc  - (max cols) pack text and padding into this many columns
  *  fc  - (fill cols) this many columns from the left/right/center will be
  *  	  filled
  *  p_? - (padding) this many cells will be skipped from ? side
  *  ds  - (display start) string starts being displayed from this display column
  * 	  counted from the start of the string; an "entry point" joining string
  * 	  index with screen
  * fill - boolean; 1 = fill fc, 0 = don't fill fc
  * srch - search string; if empty or NULL no highlighting happens
  * sfg  - fg color of search highlght
  * sbg  - bg color of search highlight
  * */
 void
 u32_draw_string(const int x, const int y, const uint16_t fg, const uint16_t bg,
 	const uint32_t* s, const int mc, const int fc, const int p_l,
 	const int p_r, const Alignment align, const int ds, const int fill,
 	const uint32_t* srch, const uint16_t sfg, const uint16_t sbg)
 {
 	/*
 	 *                   <-------- visible part ---------->
 	 *        +---------+-------+----------------+---------+
 	 *        |         |       |                |         |
 	 *        |<-- d -->|<-p_l->|<------ c ----->|<- p_r ->|
 	 *        |         |<-------------- mc -------------->|
 	 *        |<------------------ fc -------------------->|
 	 *        x                 |                |
 	 *                          ds               ds+c
 	 *                           <.....(sc).....>
 	 *                      (align == RIGHT in this case)
 	 * */
 
 	int d = 0; /* distance, in screen columns, from x to
 		    * visible part of the string, followed by
 		    * p_l */
 
 	int c = 0; /* distance in screen columns from
 		    * d + p_l to d + mc - p_r (part of the
 		    * displayed string containing text, between
 		    * padding; string fits within this many columns
 		    * */
 
 	int sc = 0; /* current screen column; goes from 0..c-1
 		     * only increased when actual characters are
 		     * written
 		     */
 
 	int ssc = 0; /* current string screen column; goes from start
 		      * of the string until ds+c */
 
 	const int ts = TAB_SIZE;
 
 	const uint32_t* ps = s; /* pointer to current character in string;
 				 * string index: ps-s */
 
 	uint16_t cfg = fg; /* current fg */
 	uint16_t cbg = bg; /* current bg */
 
 	int hctl = 0; /* highlight "characters to live", when this
 		       * reaches zero the highlighting is turned
 		       * off */
 
 	int j;
 
 	c = mc - p_l - p_r;
 
 	if (align == LEFT)
 		d = 0;
 	else if (align == RIGHT)
 		d = fc >= mc ? fc - mc : 0;
 	else if (align == CENTER)
 		d = fc >= mc ? (fc - mc) / 2 : 0;
 
 	/* fill */
 	if (fill)
 		for (j = 0; j < fc; j++)
 			tb_set_cell(x + j, y, ' ', fg, bg);
 
 	/* left padding */
 	for (j = 0; j < p_l; j++)
 		tb_set_cell(x + d + j, y, ' ', fg, bg);
 
 	sc = 0;
 
 	/*
 	 * main idea: we go from start of the string to the end and count
 	 * displayed characters until we get to ds, then we also output
 	 * characters; tabs count as spaces up to multiple of ts, counted from
 	 * the start of the string
 	 *
 	 * exit condition is also sc == c, when we have reached the maximum
 	 * number of characters to output
 	 * */
 	while (ps && *ps && sc < c)
 	{
 		if (srch && *srch && hctl == 0)
 		{
 			if (u32_starts_with(ps, srch))
 			{
 				hctl = u32_strlen(srch);
 				cfg  = sfg;
 				cbg  = sbg;
 			}
 		}
 
 		if (*ps == '\t')
 		{
 			if (ssc < ds)
 			{
 				/*                     ssc-(ssc%ts)+ts
 				 *              \t     |  = ssc+(ts-(ssc%ts))
 				 *  ----------|-----[ :|::: ]
 				 *            | |     |
 				 *            | |     ds
 				 * ssc-(ssc%ts) |
 				 *              ssc
 				 * */
 				if (ssc - (ssc % ts) + ts >= ds)
 				{
 					for (j = 0;
 						j < ssc - (ssc % ts) + ts - ds;
 						j++)
 						tb_set_cell(x + d + p_l + sc + j,
 							y, ' ', cfg, cbg);
 					sc += ssc + (ts - (ssc % ts)) - ds;
 					hctl -= ssc + (ts - (ssc % ts)) - ds;
 					if (hctl < 0)
 						hctl = 0;
 				}
 				/* else, just increase counter
 				 *
 				 * \t
 				 * ----------|----[ ::::: ]
 				 * |         |      |
 				 * |         |      ds
 				 * |         ssc-(ssc%ts)+ts
 				 * ssc         = ssc + (ts-(ssc%ts))
 				 * */
 				ssc += (ts - (ssc % ts));
 			}
 			else /* ssc >= ds */
 			{
 				/*
 				 *   ds          ssc+(ts-(ssc%ts))
 				 *   |   \t      |
 				 * [ ::::::: ]---|-----
 				 *       |  |
 				 *       |  ds+c
 				 *       ssc
 				 * */
 				if (ssc + (ts - (ssc % ts)) >= ds + c)
 				{
 					for (j = 0; j < ds + c - ssc; j++)
 						tb_set_cell(x + d + p_l + sc + j,
 							y, ' ', cfg, cbg);
 					sc   = c;
 					ssc  = ds + c;
 					hctl = 0;
 					cfg  = fg;
 					cbg  = bg;
 				}
 				else /* ssc+(ts-(ssc%ts)) < ds+c */
 				{
 					/*
 					 *      \t
 					 * [ :::::::::::|::: ]-----
 					 *   |  |       |   |
 					 *   |  |       |   ds+c
 					 *   |  |       ssc+(ts-(ssc%ts))
 					 *   |  ssc
 					 *   ds
 					 * */
 					for (j = 0; j < ts - (ssc % ts); j++)
 						tb_set_cell(x + d + p_l + sc + j,
 							y, ' ', cfg, cbg);
 					sc += ts - (ssc % ts);
 					hctl -= ts - (ssc % ts);
 					if (hctl < 0)
 						hctl = 0;
 					ssc += ts - (ssc % ts);
 				}
 			}
 		}
 		else
 		{
 			if (ssc >= ds)
 			{
 				if (sc < c)
 					tb_set_cell(x + d + p_l + sc, y, *ps,
 						cfg, cbg);
 				sc++;
 				hctl--;
 				if (hctl < 0)
 					hctl = 0;
 			}
 			ssc++;
 		}
 		if (hctl == 0)
 		{
 			cfg = fg;
 			cbg = bg;
 		}
 		ps++;
 	}
 
 	/* right padding */
 	for (j = 0; j < p_r; j++)
 		tb_set_cell(x + d + p_l + c + j, y, ' ', fg, bg);
 }