Initial commit

This is mostly sdtui code ported over from GLib to liberty,
with some MPD code from desktop-tools.

It tracks the current song and that's it.

1 files changed, 1506 insertions, 0 deletions

diff --git a/nncmpp.c b/nncmpp.c
new file mode 100644
index 0000000..27c175b
--- /dev/null
+++ b/nncmpp.c
@@ -0,0 +1,1506 @@
+/*
+ * nncmpp -- the MPD client you never knew you needed
+ *
+ * Copyright (c) 2016, Přemysl Janouch <p.janouch@gmail.com>
+ * All rights reserved.
+ *
+ * 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 "config.h"
+
+// My battle-tested C framework acting as a GLib replacement.  Its one big
+// disadvantage is missing support for i18n but that can eventually be added
+// as an optional feature.  Localised applications look super awkward, though.
+
+#define LIBERTY_WANT_POLLER
+#define LIBERTY_WANT_ASYNC
+#include "liberty/liberty.c"
+
+#include <sys/un.h>
+#include "mpd.c"
+
+#include <locale.h>
+#include <termios.h>
+#ifndef TIOCGWINSZ
+#include <sys/ioctl.h>
+#endif  // ! TIOCGWINSZ
+#include <ncurses.h>
+
+// ncurses is notoriously retarded for input handling, we need something
+// different if only to receive mouse events reliably.
+
+#include "termo.h"
+
+// It is surprisingly hard to find a good library to handle Unicode shenanigans,
+// and there's enough of those for it to be impractical to reimplement them.
+//
+//                         GLib          ICU     libunistring    utf8proc
+// Decently sized            .            .            x            x
+// Grapheme breaks           .            x            .            x
+// Character width           x            .            x            x
+// Locale handling           .            .            x            .
+// Liberal license           .            x            .            x
+//
+// Also note that the ICU API is icky and uses UTF-16 for its primary encoding.
+//
+// Currently we're chugging along with libunistring but utf8proc seems viable.
+// Non-Unicode locales can mostly be handled with simple iconv like in sdtui.
+// Similarly grapheme breaks can be guessed at using character width (a basic
+// test here is Zalgo text).
+//
+// None of this is ever going to work too reliably anyway because terminals
+// and Unicode don't go awfully well together.  In particular, character cell
+// devices have some problems with double-wide characters.
+
+#include <unistr.h>
+#include <uniwidth.h>
+#include <uniconv.h>
+
+#define CTRL_KEY(x)  ((x) - 'A' + 1)
+
+#define APP_TITLE  PROGRAM_NAME " "     ///< Left top corner
+
+// --- Utilities ---------------------------------------------------------------
+
+// The standard endwin/refresh sequence makes the terminal flicker
+static void
+update_curses_terminal_size (void)
+{
+#if defined (HAVE_RESIZETERM) && defined (TIOCGWINSZ)
+	struct winsize size;
+	if (!ioctl (STDOUT_FILENO, TIOCGWINSZ, (char *) &size))
+	{
+		char *row = getenv ("LINES");
+		char *col = getenv ("COLUMNS");
+		unsigned long tmp;
+		resizeterm (
+			(row && xstrtoul (&tmp, row, 10)) ? tmp : size.ws_row,
+			(col && xstrtoul (&tmp, col, 10)) ? tmp : size.ws_col);
+	}
+#else  // HAVE_RESIZETERM && TIOCGWINSZ
+	endwin ();
+	refresh ();
+#endif  // HAVE_RESIZETERM && TIOCGWINSZ
+}
+
+// --- Application -------------------------------------------------------------
+
+// Function names are prefixed mostly because of curses which clutters the
+// global namespace and makes it harder to distinguish what functions relate to.
+
+// Avoiding colours in the defaults here in order to support dumb terminals
+#define ATTRIBUTE_TABLE(XX)                            \
+	XX( HEADER, "header",        -1, -1, A_REVERSE   ) \
+	XX( ACTIVE, "header_active", -1, -1, A_UNDERLINE ) \
+	XX( EVEN,   "even",          -1, -1, 0           ) \
+	XX( ODD,    "odd",           -1, -1, 0           )
+
+enum
+{
+#define XX(name, config, fg_, bg_, attrs_) ATTRIBUTE_ ## name,
+	ATTRIBUTE_TABLE (XX)
+#undef XX
+	ATTRIBUTE_COUNT
+};
+
+struct attrs
+{
+	short fg;                           ///< Foreground colour index
+	short bg;                           ///< Background colour index
+	chtype attrs;                       ///< Other attributes
+};
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// The user interface is focused on conceptual simplicity.  That is important
+// since we're not using any TUI framework (which are mostly a lost cause to me
+// in the post-Unicode era and not worth pursuing), and the code would get
+// bloated and incomprehensible fast.  We mostly rely on app_add_utf8_string()
+// to write text from left to right row after row while keeping track of cells.
+//
+// There is an independent top pane displaying general status information,
+// followed by a tab bar and a listview served by a per-tab event handler.
+//
+// For simplicity, the listview can only work with items that are one row high.
+
+struct tab;
+struct row_buffer;
+
+/// Try to handle an event in the tab
+typedef bool (*tab_event_fn) (struct tab *self, termo_key_t *event);
+
+/// Draw an item to the screen using the row buffer API
+typedef void (*tab_item_draw_fn)
+	(struct tab *self, unsigned item_index, struct row_buffer *buffer);
+
+struct tab
+{
+	LIST_HEADER (struct tab)
+
+	char *name;                         ///< Visible identifier
+	size_t name_width;                  ///< Visible width of the name
+
+	// Implementation:
+
+	// TODO: free() callback?
+	tab_event_fn on_event;              ///< Event handler callback
+	tab_item_draw_fn on_item_draw;      ///< Item draw callback
+
+	// Provided by tab owner:
+
+	bool can_multiselect;               ///< Multiple items can be selected
+	size_t item_count;                  ///< Total item count
+
+	// Managed by the common handler:
+
+	int item_top;                       ///< Index of the topmost item
+	int item_selected;                  ///< Index of the selected item
+};
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+enum player_state { PLAYER_STOPPED, PLAYER_PLAYING, PLAYER_PAUSED };
+
+// Basically a container for most of the globals; no big sense in handing
+// around a pointer to this, hence it is a simple global variable as well.
+// There is enough global state as it is.
+
+static struct app_context
+{
+	// Event loop:
+
+	struct poller poller;               ///< Poller
+	bool quitting;                      ///< Quit signal for the event loop
+	bool polling;                       ///< The event loop is running
+
+	struct poller_fd tty_event;         ///< Terminal input event
+	struct poller_fd signal_event;      ///< Signal FD event
+
+	// Connection:
+
+	struct mpd_client client;           ///< MPD client interface
+	struct poller_timer reconnect_event;///< MPD reconnect timer
+
+	enum player_state state;            ///< Player state
+	// TODO: probably save the full info reply
+	char *song;                         ///< Currently playing song
+
+	// Data:
+
+	struct config config;               ///< Program configuration
+
+	struct tab *tabs;                   ///< All tabs
+	struct tab *active_tab;             ///< Active tab
+
+	// Terminal:
+
+	termo_t *tk;                        ///< termo handle
+	struct poller_timer tk_timer;       ///< termo timeout timer
+	bool locale_is_utf8;                ///< The locale is Unicode
+
+	int list_offset;                    ///< Height of the top part
+
+	struct attrs attrs[ATTRIBUTE_COUNT];
+}
+g_ctx;
+
+/// Shortcut to retrieve named terminal attributes
+#define APP_ATTR(name) g_ctx.attrs[ATTRIBUTE_ ## name].attrs
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static void
+tab_init (struct tab *self, const char *name)
+{
+	memset (self, 0, sizeof *self);
+
+	// Add some padding for decorative purposes
+	self->name = xstrdup_printf (" %s ", name);
+	// Assuming tab names are pure ASCII, otherwise this would be inaccurate
+	// and we'd need to filter it first to replace invalid chars with '?'
+	self->name_width = u8_strwidth ((uint8_t *) self->name, locale_charset ());
+	self->item_selected = -1;
+}
+
+static void
+tab_free (struct tab *self)
+{
+	free (self->name);
+}
+
+// --- Configuration -----------------------------------------------------------
+
+static struct config_schema g_config_settings[] =
+{
+	{ .name      = "address",
+	  .comment   = "Address to connect to the MPD server",
+	  .type      = CONFIG_ITEM_STRING,
+	  .default_  = "localhost" },
+	{ .name      = "password",
+	  .comment   = "Password to use for MPD authentication",
+	  .type      = CONFIG_ITEM_STRING },
+	{ .name      = "root",
+	  .comment   = "Where all the files MPD is playing are located",
+	  .type      = CONFIG_ITEM_STRING },
+	{}
+};
+
+static struct config_schema g_config_colors[] =
+{
+#define XX(name_, config, fg_, bg_, attrs_) \
+	{ .name = config, .type = CONFIG_ITEM_STRING },
+	ATTRIBUTE_TABLE (XX)
+#undef XX
+	{}
+};
+
+static const char *
+get_config_string (struct config_item *root, const char *key)
+{
+	struct config_item *item = config_item_get (root, key, NULL);
+	hard_assert (item);
+	if (item->type == CONFIG_ITEM_NULL)
+		return NULL;
+	hard_assert (config_item_type_is_string (item->type));
+	return item->value.string.str;
+}
+
+/// Load configuration for a color using a subset of git config colors
+static void
+app_load_color (struct config_item *subtree, const char *name, int id)
+{
+	const char *value = get_config_string (subtree, name);
+	if (!value)
+		return;
+
+	struct str_vector v;
+	str_vector_init (&v);
+	cstr_split_ignore_empty (value, ' ', &v);
+
+	int colors = 0;
+	struct attrs attrs = { -1, -1, 0 };
+	for (char **it = v.vector; *it; it++)
+	{
+		char *end = NULL;
+		long n = strtol (*it, &end, 10);
+		if (*it != end && !*end && n >= SHRT_MIN && n <= SHRT_MAX)
+		{
+			if (colors == 0) attrs.fg = n;
+			if (colors == 1) attrs.bg = n;
+			colors++;
+		}
+		else if (!strcmp (*it, "bold"))    attrs.attrs |= A_BOLD;
+		else if (!strcmp (*it, "dim"))     attrs.attrs |= A_DIM;
+		else if (!strcmp (*it, "ul"))      attrs.attrs |= A_UNDERLINE;
+		else if (!strcmp (*it, "blink"))   attrs.attrs |= A_BLINK;
+		else if (!strcmp (*it, "reverse")) attrs.attrs |= A_REVERSE;
+#ifdef A_ITALIC
+		else if (!strcmp (*it, "italic"))  attrs.attrs |= A_ITALIC;
+#endif  // A_ITALIC
+	}
+	str_vector_free (&v);
+	g_ctx.attrs[id] = attrs;
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static void
+load_config_settings (struct config_item *subtree, void *user_data)
+{
+	config_schema_apply_to_object (g_config_settings, subtree, user_data);
+}
+
+static void
+load_config_colors (struct config_item *subtree, void *user_data)
+{
+	config_schema_apply_to_object (g_config_colors,   subtree, user_data);
+
+	// The attributes cannot be changed dynamically right now, so it doesn't
+	// make much sense to make use of "on_change" callbacks either.
+	// For simplicity, we should reload the entire table on each change anyway.
+#define XX(name, config, fg_, bg_, attrs_) \
+	app_load_color (subtree, config, ATTRIBUTE_ ## name);
+	ATTRIBUTE_TABLE (XX)
+#undef XX
+}
+
+static void
+app_load_configuration (void)
+{
+	struct config *config = &g_ctx.config;
+	config_register_module (config, "settings", load_config_settings, NULL);
+	config_register_module (config, "colors",   load_config_colors,   NULL);
+
+	char *filename = resolve_filename
+		(PROGRAM_NAME ".conf", resolve_relative_config_filename);
+	if (!filename)
+		return;
+
+	struct error *e = NULL;
+	struct config_item *root = config_read_from_file (filename, &e);
+	free (filename);
+
+	if (e)
+	{
+		print_error ("error loading configuration: %s", e->message);
+		error_free (e);
+		exit (EXIT_FAILURE);
+	}
+	if (root)
+	{
+		config_load (&g_ctx.config, root);
+		config_schema_call_changed (g_ctx.config.root);
+	}
+}
+
+// --- Application -------------------------------------------------------------
+
+static void
+app_init_attributes (void)
+{
+#define XX(name, config, fg_, bg_, attrs_)          \
+	g_ctx.attrs[ATTRIBUTE_ ## name].fg    = fg_;    \
+	g_ctx.attrs[ATTRIBUTE_ ## name].bg    = bg_;    \
+	g_ctx.attrs[ATTRIBUTE_ ## name].attrs = attrs_;
+	ATTRIBUTE_TABLE (XX)
+#undef XX
+}
+
+static void
+app_init_context (void)
+{
+	memset (&g_ctx, 0, sizeof g_ctx);
+
+	poller_init (&g_ctx.poller);
+	mpd_client_init (&g_ctx.client, &g_ctx.poller);
+	config_init (&g_ctx.config);
+
+	// This is also approximately what libunistring does internally,
+	// since the locale name is canonicalized by locale_charset().
+	// Note that non-Unicode locales are handled pretty inefficiently.
+	g_ctx.locale_is_utf8 = !strcasecmp_ascii (locale_charset (), "UTF-8");
+
+	app_init_attributes ();
+}
+
+static void
+app_init_terminal (void)
+{
+	TERMO_CHECK_VERSION;
+	if (!(g_ctx.tk = termo_new (STDIN_FILENO, NULL, 0)))
+		abort ();
+	if (!initscr () || nonl () == ERR)
+		abort ();
+
+	// Disable cursor, we're not going to use it most of the time
+	curs_set (0);
+
+	// By default we don't use any colors so they're not required...
+	if (start_color () == ERR
+	 || use_default_colors () == ERR
+	 || COLOR_PAIRS <= ATTRIBUTE_COUNT)
+		return;
+
+	for (int a = 0; a < ATTRIBUTE_COUNT; a++)
+	{
+		// ...thus we can reset back to defaults even after initializing some
+		if (g_ctx.attrs[a].fg >= COLORS || g_ctx.attrs[a].fg < -1
+		 || g_ctx.attrs[a].bg >= COLORS || g_ctx.attrs[a].bg < -1)
+		{
+			app_init_attributes ();
+			return;
+		}
+
+		init_pair (a + 1, g_ctx.attrs[a].fg, g_ctx.attrs[a].bg);
+		g_ctx.attrs[a].attrs |= COLOR_PAIR (a + 1);
+	}
+}
+
+static void
+app_free_context (void)
+{
+	mpd_client_free (&g_ctx.client);
+	free (g_ctx.song);
+
+	config_free (&g_ctx.config);
+	poller_free (&g_ctx.poller);
+
+	if (g_ctx.tk)
+		termo_destroy (g_ctx.tk);
+}
+
+static void
+app_quit (void)
+{
+	g_ctx.quitting = true;
+
+	// TODO: bring down the MPD interface (if that's needed at all);
+	//   so far there's nothing for us to wait on, so let's just stop looping
+	g_ctx.polling = false;
+}
+
+static bool
+app_is_character_in_locale (ucs4_t ch)
+{
+	// Avoid the overhead joined with calling iconv() for all characters.
+	if (g_ctx.locale_is_utf8)
+		return true;
+
+	// The library really creates a new conversion object every single time
+	// and doesn't provide any smarter APIs.  Luckily, most users use UTF-8.
+	size_t len;
+	char *tmp = u32_conv_to_encoding (locale_charset (), iconveh_error,
+		&ch, 1, NULL, NULL, &len);
+	if (!tmp)
+		return false;
+	free (tmp);
+	return true;
+}
+
+// --- Terminal output ---------------------------------------------------------
+
+// Necessary abstraction to simplify aligned, formatted character output
+
+struct row_char
+{
+	LIST_HEADER (struct row_char)
+
+	ucs4_t c;                           ///< Unicode codepoint
+	chtype attrs;                       ///< Special attributes
+	int width;                          ///< How many cells this takes
+};
+
+struct row_buffer
+{
+	struct row_char *chars;             ///< Characters
+	struct row_char *chars_tail;        ///< Tail of characters
+	size_t chars_len;                   ///< Character count
+	int total_width;                    ///< Total width of all characters
+};
+
+static void
+row_buffer_init (struct row_buffer *self)
+{
+	memset (self, 0, sizeof *self);
+}
+
+static void
+row_buffer_free (struct row_buffer *self)
+{
+	LIST_FOR_EACH (struct row_char, it, self->chars)
+		free (it);
+}
+
+/// Replace invalid chars and push all codepoints to the array w/ attributes.
+static void
+row_buffer_append (struct row_buffer *self, const char *str, chtype attrs)
+{
+	// The encoding is only really used internally for some corner cases
+	const char *encoding = locale_charset ();
+
+	ucs4_t c;
+	const uint8_t *start = (const uint8_t *) str, *next = start;
+	while ((next = u8_next (&c, next)))
+	{
+		if (uc_width (c, encoding) < 0
+		 || !app_is_character_in_locale (c))
+			c = '?';
+
+		struct row_char *rc = xmalloc (sizeof *rc);
+		*rc = (struct row_char)
+			{ .c = c, .attrs = attrs, .width = uc_width (c, encoding) };
+		LIST_APPEND_WITH_TAIL (self->chars, self->chars_tail, rc);
+		self->chars_len++;
+		self->total_width += rc->width;
+	}
+}
+
+/// Pop as many codepoints as needed to free up "space" character cells.
+/// Given the suffix nature of combining marks, this should work pretty fine.
+static int
+row_buffer_pop_cells (struct row_buffer *self, int space)
+{
+	int made = 0;
+	while (self->chars && made < space)
+	{
+		struct row_char *tail = self->chars_tail;
+		LIST_UNLINK_WITH_TAIL (self->chars, self->chars_tail, tail);
+		self->chars_len--;
+		made += tail->width;
+		free (tail);
+	}
+	self->total_width -= made;
+	return made;
+}
+
+static void
+row_buffer_ellipsis (struct row_buffer *self, int target, chtype attrs)
+{
+	row_buffer_pop_cells (self, self->total_width - target);
+
+	ucs4_t ellipsis = L'…';
+	if (app_is_character_in_locale (ellipsis))
+	{
+		if (self->total_width >= target)
+			row_buffer_pop_cells (self, 1);
+		if (self->total_width + 1 <= target)
+			row_buffer_append (self, "…", attrs);
+	}
+	else if (target >= 3)
+	{
+		if (self->total_width >= target)
+			row_buffer_pop_cells (self, 3);
+		if (self->total_width + 3 <= target)
+			row_buffer_append (self, "...", attrs);
+	}
+}
+
+static void
+row_buffer_print (uint32_t *ucs4, chtype attrs)
+{
+	// Cannot afford to convert negative numbers to the unsigned chtype.
+	uint8_t *str = (uint8_t *) u32_strconv_to_locale (ucs4);
+	if (str)
+	{
+		for (uint8_t *p = str; *p; p++)
+			addch (*p | attrs);
+		free (str);
+	}
+}
+
+static void
+row_buffer_flush (struct row_buffer *self)
+{
+	if (!self->chars)
+		return;
+
+	// We only NUL-terminate the chunks because of the libunistring API
+	uint32_t chunk[self->chars_len + 1], *insertion_point = chunk;
+	LIST_FOR_EACH (struct row_char, it, self->chars)
+	{
+		if (it->prev && it->attrs != it->prev->attrs)
+		{
+			row_buffer_print (chunk, it->prev->attrs);
+			insertion_point = chunk;
+		}
+		*insertion_point++ = it->c;
+		*insertion_point = 0;
+	}
+	row_buffer_print (chunk, self->chars_tail->attrs);
+}
+
+// --- Help tab ----------------------------------------------------------------
+
+// TODO: either find something else to put in here or remove the wrapper struct
+static struct
+{
+	struct tab super;                   ///< Parent class
+}
+g_help_tab;
+
+static struct help_tab_item
+{
+	const char *text;                   ///< Item text
+}
+g_help_items[] =
+{
+	{ "First entry on the list" },
+	{ "Something different" },
+	{ "Yet another item" },
+};
+
+static void
+help_tab_on_item_draw (struct tab *self, unsigned item_index,
+	struct row_buffer *buffer)
+{
+	(void) self;
+
+	hard_assert (item_index <= N_ELEMENTS (g_help_items));
+	row_buffer_append (buffer, g_help_items[item_index].text, 0);
+}
+
+static struct tab *
+help_tab_create ()
+{
+	struct tab *super = &g_help_tab.super;
+	tab_init (super, "Help");
+	super->on_item_draw = help_tab_on_item_draw;
+	super->item_count = N_ELEMENTS (g_help_items);
+	super->item_selected = 0;
+	return super;
+}
+
+// --- Application -------------------------------------------------------------
+
+/// Write the given UTF-8 string padded with spaces.
+/// @param[in] n  The number of characters to write, or -1 for the whole string.
+/// @param[in] attrs  Text attributes for the text, without padding.
+///                   To change the attributes of all output, use attrset().
+/// @return The number of characters output.
+static size_t
+app_write_utf8 (const char *str, chtype attrs, int n)
+{
+	if (!n)
+		return 0;
+
+	struct row_buffer buf;
+	row_buffer_init (&buf);
+	row_buffer_append (&buf, str, attrs);
+
+	if (n < 0)
+		n = buf.total_width;
+	if (buf.total_width > n)
+		row_buffer_ellipsis (&buf, n, attrs);
+
+	row_buffer_flush (&buf);
+	for (int i = buf.total_width; i < n; i++)
+		addch (' ');
+
+	row_buffer_free (&buf);
+	return n;
+}
+
+static void
+app_redraw_top (void)
+{
+	// TODO: this will eventually be dynamically computed depending on contents
+	g_ctx.list_offset = 2;
+
+	attrset (0);
+	mvwhline (stdscr, 0, 0, 0, COLS);
+	switch (g_ctx.client.state)
+	{
+	case MPD_CONNECTED:
+		switch (g_ctx.state)
+		{
+		case PLAYER_PLAYING:
+		case PLAYER_PAUSED:
+			app_write_utf8 (g_ctx.song, 0, COLS);
+			break;
+		case PLAYER_STOPPED:
+			app_write_utf8 ("Stopped", 0, COLS);
+		}
+		break;
+	case MPD_CONNECTING:
+		app_write_utf8 ("Connecting to MPD...", 0, COLS);
+		break;
+	case MPD_DISCONNECTED:
+		app_write_utf8 ("Disconnected", 0, COLS);
+	}
+
+	attrset (APP_ATTR (HEADER));
+	mvwhline (stdscr, 1, 0, APP_ATTR (HEADER), COLS);
+	// TODO: render this with APP_ATTR (ACTIVE) when the help tab is selected;
+	//   ...maybe the help tab should not even be on the list?
+	size_t indent = app_write_utf8 (APP_TITLE, A_BOLD, -1);
+
+	attrset (0);
+	LIST_FOR_EACH (struct tab, it, g_ctx.tabs)
+	{
+		indent += app_write_utf8 (it->name,
+			it == g_ctx.active_tab ? APP_ATTR (ACTIVE) : APP_ATTR (HEADER),
+			MIN (COLS - indent, it->name_width));
+	}
+	refresh ();
+}
+
+static void
+app_redraw_view (void)
+{
+	move (g_ctx.list_offset, 0);
+	clrtobot ();
+
+	// TODO: display a scrollbar on the right side
+	struct tab *tab = g_ctx.active_tab;
+	int to_show = MIN (LINES - g_ctx.list_offset,
+		(int) tab->item_count - tab->item_top);
+	for (int row_index = 0; row_index < to_show; row_index++)
+	{
+		unsigned item_index = tab->item_top + row_index;
+		int row_attrs = (item_index & 1) ? APP_ATTR (ODD) : APP_ATTR (EVEN);
+		if ((int) item_index == tab->item_selected)
+			row_attrs |= A_REVERSE;
+
+		attrset (row_attrs);
+
+		struct row_buffer buf;
+		row_buffer_init (&buf);
+
+		tab->on_item_draw (tab, item_index, &buf);
+		if (buf.total_width > COLS)
+			row_buffer_ellipsis (&buf, COLS, row_attrs);
+
+		row_buffer_flush (&buf);
+		for (int i = buf.total_width; i < COLS; i++)
+			addch (' ');
+		row_buffer_free (&buf);
+	}
+
+	attrset (0);
+	refresh ();
+}
+
+static void
+app_redraw (void)
+{
+	app_redraw_top ();
+	app_redraw_view ();
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+/// Scroll up @a n items.  Doesn't redraw.
+static bool
+app_scroll_up (int n)
+{
+	struct tab *tab = g_ctx.active_tab;
+	if (tab->item_top < n)
+	{
+		tab->item_top = 0;
+		return false;
+	}
+	tab->item_top -= n;
+	return true;
+}
+
+/// Scroll down @a n items.  Doesn't redraw.
+static bool
+app_scroll_down (int n)
+{
+	struct tab *tab = g_ctx.active_tab;
+	// TODO: if (n_items >= lines), don't allow to scroll off past the end
+	if ((tab->item_top += n) >= (int) tab->item_count)
+	{
+		if (tab->item_count)
+			tab->item_top = tab->item_count - 1;
+		else
+			tab->item_top = 0;
+		return false;
+	}
+	return true;
+}
+
+/// Moves the selection one item up.
+static bool
+app_one_item_up (void)
+{
+	struct tab *tab = g_ctx.active_tab;
+	if (tab->item_selected < 1)
+		return false;
+
+	if (--tab->item_selected < tab->item_top)
+		app_scroll_up (tab->item_top - tab->item_selected);
+
+	app_redraw_view ();
+	return true;
+}
+
+/// Moves the selection one item down.
+static bool
+app_one_item_down (void)
+{
+	struct tab *tab = g_ctx.active_tab;
+	if (tab->item_selected + 1 >= (int) tab->item_count)
+		return false;
+
+	int n_visible = LINES - g_ctx.list_offset;
+	if (++tab->item_selected >= tab->item_top + n_visible)
+		app_scroll_down (1);
+
+	app_redraw_view ();
+	return true;
+}
+
+static bool
+app_goto_tab (unsigned n)
+{
+	// TODO: go to tab n, return false if out of range
+	return false;
+
+	app_redraw ();
+	return true;
+}
+
+static void
+app_process_resize (void)
+{
+	struct tab *tab = g_ctx.active_tab;
+	if (tab->item_selected < 0)
+		return;
+
+	int n_visible = LINES - g_ctx.list_offset;
+	if (n_visible < 0)
+		return;
+
+	// Scroll up as needed to keep the selection visible
+	int selected_offset = tab->item_selected - tab->item_top;
+	if (selected_offset >= n_visible)
+		app_scroll_up (selected_offset - n_visible + 1);
+
+	app_redraw ();
+}
+
+// --- User input handling -----------------------------------------------------
+
+enum user_action
+{
+	USER_ACTION_NONE,
+
+	USER_ACTION_QUIT,
+	USER_ACTION_REDRAW,
+
+	USER_ACTION_GOTO_ITEM_PREVIOUS,
+	USER_ACTION_GOTO_ITEM_NEXT,
+	USER_ACTION_GOTO_PAGE_PREVIOUS,
+	USER_ACTION_GOTO_PAGE_NEXT,
+
+	USER_ACTION_COUNT
+};
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static bool
+app_process_user_action (enum user_action action)
+{
+	switch (action)
+	{
+	case USER_ACTION_QUIT:
+		return false;
+	case USER_ACTION_REDRAW:
+		clear ();
+		app_redraw ();
+		return true;
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	case USER_ACTION_GOTO_ITEM_PREVIOUS:
+		app_one_item_up ();
+		return true;
+	case USER_ACTION_GOTO_ITEM_NEXT:
+		app_one_item_down ();
+		return true;
+
+	case USER_ACTION_GOTO_PAGE_PREVIOUS:
+		app_scroll_up (LINES - (int) g_ctx.list_offset);
+		app_redraw_view ();
+		return true;
+	case USER_ACTION_GOTO_PAGE_NEXT:
+		app_scroll_down (LINES - (int) g_ctx.list_offset);
+		app_redraw_view ();
+		return true;
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	case USER_ACTION_NONE:
+		return true;
+	default:
+		hard_assert (!"unhandled user action");
+	}
+	return true;
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static bool
+app_process_keysym (termo_key_t *event)
+{
+	enum user_action action = USER_ACTION_NONE;
+	typedef const enum user_action ActionMap[TERMO_N_SYMS];
+
+	static ActionMap actions =
+	{
+		[TERMO_SYM_ESCAPE]    = USER_ACTION_QUIT,
+
+		[TERMO_SYM_UP]        = USER_ACTION_GOTO_ITEM_PREVIOUS,
+		[TERMO_SYM_DOWN]      = USER_ACTION_GOTO_ITEM_NEXT,
+		[TERMO_SYM_PAGEUP]    = USER_ACTION_GOTO_PAGE_PREVIOUS,
+		[TERMO_SYM_PAGEDOWN]  = USER_ACTION_GOTO_PAGE_NEXT,
+	};
+	static ActionMap actions_alt =
+	{
+	};
+	static ActionMap actions_ctrl =
+	{
+	};
+
+	if (!event->modifiers)
+		action = actions[event->code.sym];
+	else if (event->modifiers == TERMO_KEYMOD_ALT)
+		action = actions_alt[event->code.sym];
+	else if (event->modifiers == TERMO_KEYMOD_CTRL)
+		action = actions_ctrl[event->code.sym];
+
+	return app_process_user_action (action);
+}
+
+static bool
+app_process_ctrl_key (termo_key_t *event)
+{
+	static const enum user_action actions[32] =
+	{
+		[CTRL_KEY ('L')]      = USER_ACTION_REDRAW,
+
+		[CTRL_KEY ('P')]      = USER_ACTION_GOTO_ITEM_PREVIOUS,
+		[CTRL_KEY ('N')]      = USER_ACTION_GOTO_ITEM_NEXT,
+		[CTRL_KEY ('B')]      = USER_ACTION_GOTO_PAGE_PREVIOUS,
+		[CTRL_KEY ('F')]      = USER_ACTION_GOTO_PAGE_NEXT,
+	};
+
+	int64_t i = (int64_t) event->code.codepoint - 'a' + 1;
+	if (i > 0 && i < (int64_t) N_ELEMENTS (actions))
+		return app_process_user_action (actions[i]);
+
+	return true;
+}
+
+static bool
+app_process_alt_key (termo_key_t *event)
+{
+	if (event->code.codepoint >= '0'
+	 && event->code.codepoint <= '9')
+	{
+		int n = event->code.codepoint - '0';
+		if (!app_goto_tab ((n == 0 ? 10 : n) - 1))
+			beep ();
+	}
+	return true;
+}
+
+static bool
+app_process_key (termo_key_t *event)
+{
+	if (event->modifiers == TERMO_KEYMOD_CTRL)
+		return app_process_ctrl_key (event);
+	if (event->modifiers == TERMO_KEYMOD_ALT)
+		return app_process_alt_key (event);
+	if (event->modifiers)
+		return true;
+
+	// TODO: normal unmodified keys will have functions as well
+	ucs4_t c = event->code.codepoint;
+	return true;
+}
+
+static void
+app_process_left_mouse_click (int line, int column)
+{
+	if (line < g_ctx.list_offset - 1)
+	{
+		// TODO: emulate some GUI widgets; this is going to be wild
+	}
+	else if (line == g_ctx.list_offset - 1)
+	{
+		struct tab *winner = NULL;
+		int indent = strlen (APP_TITLE);
+		// TODO: set the winner to the special help tab in this case
+		if (column < indent)
+			return;
+		for (struct tab *iter = g_ctx.tabs; !winner && iter; iter = iter->next)
+		{
+			if (column < (indent += iter->name_width))
+				winner = iter;
+		}
+		if (winner)
+		{
+			g_ctx.active_tab = winner;
+			app_redraw ();
+		}
+	}
+	else
+	{
+		struct tab *tab = g_ctx.active_tab;
+		int row_index = line - g_ctx.list_offset;
+		if (row_index >= (int) tab->item_count - tab->item_top)
+			return;
+
+		tab->item_selected = row_index + tab->item_top;
+		app_redraw_view ();
+	}
+}
+
+static bool
+app_process_mouse (termo_key_t *event)
+{
+	int line, column, button;
+	termo_mouse_event_t type;
+	termo_interpret_mouse (g_ctx.tk, event, &type, &button, &line, &column);
+
+	if (type != TERMO_MOUSE_PRESS)
+		return true;
+
+	if (button == 1)
+		app_process_left_mouse_click (line, column);
+	else if (button == 4)
+		app_process_user_action (USER_ACTION_GOTO_ITEM_PREVIOUS);
+	else if (button == 5)
+		app_process_user_action (USER_ACTION_GOTO_ITEM_NEXT);
+
+	return true;
+}
+
+static bool
+app_process_termo_event (termo_key_t *event)
+{
+	switch (event->type)
+	{
+	case TERMO_TYPE_MOUSE:
+		return app_process_mouse (event);
+	case TERMO_TYPE_KEY:
+		return app_process_key (event);
+	case TERMO_TYPE_KEYSYM:
+		return app_process_keysym (event);
+	default:
+		return true;
+	}
+}
+
+// --- Signals -----------------------------------------------------------------
+
+static int g_signal_pipe[2];            ///< A pipe used to signal... signals
+
+/// Program termination has been requested by a signal
+static volatile sig_atomic_t g_termination_requested;
+/// The window has changed in size
+static volatile sig_atomic_t g_winch_received;
+
+static void
+signals_postpone_handling (char id)
+{
+	int original_errno = errno;
+	if (write (g_signal_pipe[1], &id, 1) == -1)
+		soft_assert (errno == EAGAIN);
+	errno = original_errno;
+}
+
+static void
+signals_superhandler (int signum)
+{
+	switch (signum)
+	{
+	case SIGWINCH:
+		g_winch_received = true;
+		signals_postpone_handling ('w');
+		break;
+	case SIGINT:
+	case SIGTERM:
+		g_termination_requested = true;
+		signals_postpone_handling ('t');
+		break;
+	default:
+		hard_assert (!"unhandled signal");
+	}
+}
+
+static void
+signals_setup_handlers (void)
+{
+	if (pipe (g_signal_pipe) == -1)
+		exit_fatal ("%s: %s", "pipe", strerror (errno));
+
+	set_cloexec (g_signal_pipe[0]);
+	set_cloexec (g_signal_pipe[1]);
+
+	// So that the pipe cannot overflow; it would make write() block within
+	// the signal handler, which is something we really don't want to happen.
+	// The same holds true for read().
+	set_blocking (g_signal_pipe[0], false);
+	set_blocking (g_signal_pipe[1], false);
+
+	signal (SIGPIPE, SIG_IGN);
+
+	struct sigaction sa;
+	sa.sa_flags = SA_RESTART;
+	sa.sa_handler = signals_superhandler;
+	sigemptyset (&sa.sa_mask);
+
+	if (sigaction (SIGWINCH, &sa, NULL) == -1
+	 || sigaction (SIGINT,   &sa, NULL) == -1
+	 || sigaction (SIGTERM,  &sa, NULL) == -1)
+		exit_fatal ("sigaction: %s", strerror (errno));
+}
+
+// --- MPD interface -----------------------------------------------------------
+
+// TODO: this entire thing has been slavishly copy-pasted from dwmstatus
+// TODO: try to move some of this code to mpd.c
+
+// Sometimes it's not that easy and there can be repeating entries
+static void
+mpd_vector_to_map (const struct str_vector *data, struct str_map *map)
+{
+	str_map_init (map);
+	map->key_xfrm = tolower_ascii_strxfrm;
+	map->free = free;
+
+	char *key, *value;
+	for (size_t i = 0; i < data->len; i++)
+	{
+		if ((key = mpd_client_parse_kv (data->vector[i], &value)))
+			str_map_set (map, key, xstrdup (value));
+		else
+			print_debug ("%s: %s", "erroneous MPD output", data->vector[i]);
+	}
+}
+
+static void
+mpd_on_info_response (const struct mpd_response *response,
+	const struct str_vector *data, void *user_data)
+{
+	(void) user_data;
+	if (!response->success)
+	{
+		print_debug ("%s: %s",
+			"retrieving MPD info failed", response->message_text);
+		return;
+	}
+
+	struct str_map map;
+	mpd_vector_to_map (data, &map);
+
+	const char *value;
+	g_ctx.state = PLAYER_PLAYING;
+	if ((value = str_map_find (&map, "state")))
+	{
+		if (!strcmp (value, "stop"))
+			g_ctx.state = PLAYER_STOPPED;
+		if (!strcmp (value, "pause"))
+			g_ctx.state = PLAYER_PAUSED;
+	}
+
+	struct str s;
+	str_init (&s);
+
+	char *mpd_song = NULL;
+	if ((value = str_map_find (&map, "title"))
+	 || (value = str_map_find (&map, "name"))
+	 || (value = str_map_find (&map, "file")))
+		str_append_printf (&s, "\"%s\"", value);
+	if ((value = str_map_find (&map, "artist")))
+		str_append_printf (&s, " by \"%s\"", value);
+	if ((value = str_map_find (&map, "album")))
+		str_append_printf (&s, " from \"%s\"", value);
+	mpd_song = str_steal (&s);
+
+	str_map_free (&map);
+
+	free (g_ctx.song);
+	g_ctx.song = mpd_song;
+	app_redraw ();
+}
+
+static void
+mpd_request_info (void)
+{
+	struct mpd_client *c = &g_ctx.client;
+
+	mpd_client_list_begin (c);
+	mpd_client_send_command (c, "currentsong", NULL);
+	mpd_client_send_command (c, "status", NULL);
+	mpd_client_list_end (c);
+	mpd_client_add_task (c, mpd_on_info_response, NULL);
+
+	mpd_client_idle (c, 0);
+}
+
+static void
+mpd_on_events (unsigned subsystems, void *user_data)
+{
+	(void) user_data;
+	struct mpd_client *c = &g_ctx.client;
+
+	if (subsystems & (MPD_SUBSYSTEM_PLAYER | MPD_SUBSYSTEM_PLAYLIST))
+		mpd_request_info ();
+	else
+		mpd_client_idle (c, 0);
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static void
+mpd_queue_reconnect (void)
+{
+	poller_timer_set (&g_ctx.reconnect_event, 5 * 1000);
+}
+
+static void
+mpd_on_password_response (const struct mpd_response *response,
+	const struct str_vector *data, void *user_data)
+{
+	(void) data;
+	(void) user_data;
+	struct mpd_client *c = &g_ctx.client;
+
+	if (response->success)
+		mpd_request_info ();
+	else
+	{
+		print_error ("%s: %s",
+			"couldn't authenticate to MPD", response->message_text);
+		mpd_client_send_command (c, "close", NULL);
+	}
+}
+
+static void
+mpd_on_connected (void *user_data)
+{
+	(void) user_data;
+	struct mpd_client *c = &g_ctx.client;
+
+	const char *password =
+		get_config_string (g_ctx.config.root, "settings.password");
+	if (password)
+	{
+		mpd_client_send_command (c, "password", password, NULL);
+		mpd_client_add_task (c, mpd_on_password_response, NULL);
+	}
+	else
+		mpd_request_info ();
+}
+
+static void
+mpd_on_failure (void *user_data)
+{
+	(void) user_data;
+	// This is also triggered both by a failed connect and a clean disconnect
+	print_error ("connection to MPD failed");
+	mpd_queue_reconnect ();
+}
+
+static void
+app_on_reconnect (void *user_data)
+{
+	(void) user_data;
+
+	struct mpd_client *c = &g_ctx.client;
+	c->on_failure   = mpd_on_failure;
+	c->on_connected = mpd_on_connected;
+	c->on_event     = mpd_on_events;
+
+	// We accept hostname/IPv4/IPv6 in pseudo-URL format, as well as sockets
+	char *address = xstrdup (get_config_string (g_ctx.config.root,
+		"settings.address")), *p = address, *host = address, *port = "6600";
+
+	// Unwrap IPv6 addresses in format_host_port_pair() format
+	char *right_bracket = strchr (p, ']');
+	if (p[0] == '[' && right_bracket)
+	{
+		*right_bracket = '\0';
+		host = p + 1;
+		p = right_bracket + 1;
+	}
+
+	char *colon = strchr (p, ':');
+	if (colon)
+	{
+		*colon = '\0';
+		port = colon + 1;
+	}
+
+	struct error *e = NULL;
+	if (!mpd_client_connect (c, host, port, &e))
+	{
+		print_error ("%s: %s", "cannot connect to MPD", e->message);
+		error_free (e);
+		mpd_queue_reconnect ();
+	}
+	free (address);
+}
+
+// --- Initialisation, event handling ------------------------------------------
+
+static void
+app_on_tty_readable (const struct pollfd *fd, void *user_data)
+{
+	(void) user_data;
+	if (fd->revents & ~(POLLIN | POLLHUP | POLLERR))
+		print_debug ("fd %d: unexpected revents: %d", fd->fd, fd->revents);
+
+	poller_timer_reset (&g_ctx.tk_timer);
+	termo_advisereadable (g_ctx.tk);
+
+	termo_key_t event;
+	termo_result_t res;
+	while ((res = termo_getkey (g_ctx.tk, &event)) == TERMO_RES_KEY)
+		if (!app_process_termo_event (&event))
+		{
+			app_quit ();
+			return;
+		}
+
+	if (res == TERMO_RES_AGAIN)
+		poller_timer_set (&g_ctx.tk_timer, termo_get_waittime (g_ctx.tk));
+	else if (res == TERMO_RES_ERROR || res == TERMO_RES_EOF)
+	{
+		app_quit ();
+		return;
+	}
+}
+
+static void
+app_on_key_timer (void *user_data)
+{
+	(void) user_data;
+
+	termo_key_t event;
+	if (termo_getkey_force (g_ctx.tk, &event) == TERMO_RES_KEY)
+		if (!app_process_termo_event (&event))
+			app_quit ();
+}
+
+static void
+app_on_signal_pipe_readable (const struct pollfd *fd, void *user_data)
+{
+	(void) user_data;
+
+	char id = 0;
+	(void) read (fd->fd, &id, 1);
+
+	if (g_termination_requested && !g_ctx.quitting)
+		app_quit ();
+
+	if (g_winch_received)
+	{
+		update_curses_terminal_size ();
+		app_process_resize ();
+		g_winch_received = false;
+	}
+}
+
+static void
+app_log_handler (void *user_data, const char *quote, const char *fmt,
+	va_list ap)
+{
+	// TODO: we might want to make use of the user_data (attribute?)
+	(void) user_data;
+
+	// We certainly don't want to end up in a possibly infinite recursion
+	static bool in_processing;
+	if (in_processing)
+		return;
+
+	in_processing = true;
+
+	struct str message;
+	str_init (&message);
+	str_append (&message, quote);
+	str_append_vprintf (&message, fmt, ap);
+
+	// If the standard error output isn't redirected, try our best at showing
+	// the message to the user; it will probably get overdrawn soon
+	// TODO: remember it somewhere so that it stays shown for a while
+	if (isatty (STDERR_FILENO))
+	{
+		// TODO: remember the position and attributes and restore them
+		attrset (A_REVERSE);
+		mvwhline (stdscr, LINES - 1, 0, A_REVERSE, COLS);
+		app_write_utf8 (message.str, 0, COLS);
+	}
+	else
+		fprintf (stderr, "%s\n", message.str);
+	str_free (&message);
+
+	in_processing = false;
+}
+
+static void
+app_init_poller_events (void)
+{
+	poller_fd_init (&g_ctx.signal_event, &g_ctx.poller, g_signal_pipe[0]);
+	g_ctx.signal_event.dispatcher = app_on_signal_pipe_readable;
+	poller_fd_set (&g_ctx.signal_event, POLLIN);
+
+	poller_fd_init (&g_ctx.tty_event, &g_ctx.poller, STDIN_FILENO);
+	g_ctx.tty_event.dispatcher = app_on_tty_readable;
+	poller_fd_set (&g_ctx.tty_event, POLLIN);
+
+	poller_timer_init (&g_ctx.tk_timer, &g_ctx.poller);
+	g_ctx.tk_timer.dispatcher = app_on_key_timer;
+
+	poller_timer_init (&g_ctx.reconnect_event, &g_ctx.poller);
+	g_ctx.reconnect_event.dispatcher = app_on_reconnect;
+	poller_timer_set (&g_ctx.reconnect_event, 0);
+}
+
+int
+main (int argc, char *argv[])
+{
+	static const struct opt opts[] =
+	{
+		{ 'd', "debug", NULL, 0, "run in debug mode" },
+		{ 'h', "help", NULL, 0, "display this help and exit" },
+		{ 'V', "version", NULL, 0, "output version information and exit" },
+		{ 0, NULL, NULL, 0, NULL }
+	};
+
+	struct opt_handler oh;
+	opt_handler_init (&oh, argc, argv, opts, NULL, "MPD client.");
+
+	int c;
+	while ((c = opt_handler_get (&oh)) != -1)
+	switch (c)
+	{
+	case 'd':
+		g_debug_mode = true;
+		break;
+	case 'h':
+		opt_handler_usage (&oh, stdout);
+		exit (EXIT_SUCCESS);
+	case 'V':
+		printf (PROGRAM_NAME " " PROGRAM_VERSION "\n");
+		exit (EXIT_SUCCESS);
+	default:
+		print_error ("wrong options");
+		opt_handler_usage (&oh, stderr);
+		exit (EXIT_FAILURE);
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	if (argc)
+	{
+		opt_handler_usage (&oh, stderr);
+		exit (EXIT_FAILURE);
+	}
+	opt_handler_free (&oh);
+
+	// We only need to convert to and from the terminal encoding
+	if (!setlocale (LC_CTYPE, ""))
+		print_warning ("failed to set the locale");
+
+	app_init_context ();
+	app_load_configuration ();
+	app_init_terminal ();
+	g_log_message_real = app_log_handler;
+
+	// TODO: create more tabs
+	// TODO: in debug mode add a tab with all messages
+	LIST_PREPEND (g_ctx.tabs, help_tab_create ());
+	g_ctx.active_tab = g_ctx.tabs;
+	app_redraw ();
+
+	signals_setup_handlers ();
+	app_init_poller_events ();
+
+	g_ctx.polling = true;
+	while (g_ctx.polling)
+		poller_run (&g_ctx.poller);
+
+	endwin ();
+	g_log_message_real = log_message_stdio;
+	app_free_context ();
+	return 0;
+}
+