diff options
| -rw-r--r-- | LICENSE | 2 | ||||
| -rw-r--r-- | liberty-tui.c | 270 | ||||
| -rw-r--r-- | liberty-xui.c | 2197 | ||||
| -rw-r--r-- | tests/fuzz.c | 21 |
4 files changed, 2198 insertions, 292 deletions
@@ -1,4 +1,4 @@ -Copyright (c) 2014 - 2022, Přemysl Eric Janouch <p@janouch.name> +Copyright (c) 2014 - 2023, Přemysl Eric Janouch <p@janouch.name> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted. diff --git a/liberty-tui.c b/liberty-tui.c deleted file mode 100644 index 2f54f6d..0000000 --- a/liberty-tui.c +++ /dev/null @@ -1,270 +0,0 @@ -/* - * liberty-tui.c: the ultimate C unlibrary: TUI - * - * Copyright (c) 2016 - 2017, Přemysl Eric Janouch <p@janouch.name> - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted. - * - * 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. - * - */ - -// This file includes some common stuff to build TUI applications with - -#include <ncurses.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> -#include <unicase.h> - -// --- Configurable display attributes ----------------------------------------- - -struct attrs -{ - short fg; ///< Foreground colour index - short bg; ///< Background colour index - chtype attrs; ///< Other attributes -}; - -/// Decode attributes in the value using a subset of the git config format, -/// ignoring all errors since it doesn't affect functionality -static struct attrs -attrs_decode (const char *value) -{ - struct strv v = strv_make (); - cstr_split (value, " ", true, &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 - } - strv_free (&v); - return attrs; -} - -// --- Terminal output --------------------------------------------------------- - -// Necessary abstraction to simplify aligned, formatted character output - -// This callback you need to implement in the application -static bool app_is_character_in_locale (ucs4_t ch); - -struct row_char -{ - ucs4_t c; ///< Unicode codepoint - chtype attrs; ///< Special attributes - int width; ///< How many cells this takes -}; - -struct row_buffer -{ - ARRAY (struct row_char, chars) ///< Characters - int total_width; ///< Total width of all characters -}; - -static struct row_buffer -row_buffer_make (void) -{ - struct row_buffer self = {}; - ARRAY_INIT_SIZED (self.chars, 256); - return self; -} - -static void -row_buffer_free (struct row_buffer *self) -{ - free (self->chars); -} - -/// 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 (); - - // Note that this function is a hotspot, try to keep it decently fast - struct row_char current = { .attrs = attrs }; - struct row_char invalid = { .attrs = attrs, .c = '?', .width = 1 }; - const uint8_t *next = (const uint8_t *) str; - while ((next = u8_next (¤t.c, next))) - { - current.width = uc_width (current.c, encoding); - if (current.width < 0 || !app_is_character_in_locale (current.c)) - current = invalid; - - ARRAY_RESERVE (self->chars, 1); - self->chars[self->chars_len++] = current; - self->total_width += current.width; - } -} - -static void -row_buffer_append_args (struct row_buffer *self, const char *s, ...) - ATTRIBUTE_SENTINEL; - -static void -row_buffer_append_args (struct row_buffer *self, const char *s, ...) -{ - va_list ap; - va_start (ap, s); - - while (s) - { - row_buffer_append (self, s, va_arg (ap, chtype)); - s = va_arg (ap, const char *); - } - va_end (ap); -} - -static void -row_buffer_append_buffer (struct row_buffer *self, const struct row_buffer *rb) -{ - ARRAY_RESERVE (self->chars, rb->chars_len); - memcpy (self->chars + self->chars_len, rb->chars, - rb->chars_len * sizeof *rb->chars); - - self->chars_len += rb->chars_len; - self->total_width += rb->total_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_len && made < space) - made += self->chars[--self->chars_len].width; - self->total_width -= made; - return made; -} - -static void -row_buffer_space (struct row_buffer *self, int width, chtype attrs) -{ - if (width < 0) - return; - - ARRAY_RESERVE (self->chars, (size_t) width); - - struct row_char space = { .attrs = attrs, .c = ' ', .width = 1 }; - self->total_width += width; - while (width-- > 0) - self->chars[self->chars_len++] = space; -} - -static void -row_buffer_ellipsis (struct row_buffer *self, int target) -{ - if (self->total_width <= target - || !row_buffer_pop_cells (self, self->total_width - target)) - return; - - // We use attributes from the last character we've removed, - // assuming that we don't shrink the array (and there's no real need) - ucs4_t ellipsis = 0x2026; // … - 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, "…", self->chars[self->chars_len].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, "...", self->chars[self->chars_len].attrs); - } -} - -static void -row_buffer_align (struct row_buffer *self, int target, chtype attrs) -{ - row_buffer_ellipsis (self, target); - row_buffer_space (self, target - self->total_width, attrs); -} - -static void -row_buffer_print (uint32_t *ucs4, chtype attrs) -{ - // This assumes that we can reset the attribute set without consequences - char *str = u32_strconv_to_locale (ucs4); - if (str) - { - attrset (attrs); - addstr (str); - attrset (0); - free (str); - } -} - -static void -row_buffer_flush (struct row_buffer *self) -{ - if (!self->chars_len) - return; - - // We only NUL-terminate the chunks because of the libunistring API - uint32_t chunk[self->chars_len + 1], *insertion_point = chunk; - for (size_t i = 0; i < self->chars_len; i++) - { - struct row_char *iter = self->chars + i; - if (i && iter[0].attrs != iter[-1].attrs) - { - row_buffer_print (chunk, iter[-1].attrs); - insertion_point = chunk; - } - *insertion_point++ = iter->c; - *insertion_point = 0; - } - row_buffer_print (chunk, self->chars[self->chars_len - 1].attrs); -} diff --git a/liberty-xui.c b/liberty-xui.c new file mode 100644 index 0000000..b6b5e24 --- /dev/null +++ b/liberty-xui.c @@ -0,0 +1,2197 @@ +/* + * liberty-xui.c: the ultimate C unlibrary: hybrid terminal/X11 UI + * + * Copyright (c) 2016 - 2023, Přemysl Eric Janouch <p@janouch.name> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted. + * + * 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. + * + */ + +// This file includes some common stuff to build terminal/X11 applications with. + +#include <ncurses.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 tdv. +// 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> +#include <unicase.h> + +#include <termios.h> +#ifndef TIOCGWINSZ +#include <sys/ioctl.h> +#endif // ! TIOCGWINSZ + +// ncurses is notoriously retarded for input handling, and in past versions +// used to process mouse events unreliably. Moreover, rxvt-unicode only +// supports the 1006 mode that ncurses also supports mode starting with 9.25. +#include "termo.h" + +// Carefully chosen to limit the possibility of ever hitting termo keymods. +enum { XUI_KEYMOD_DOUBLE_CLICK = 1 << 15 }; + +// Elementary port of TUI facilities to X11. +#ifdef LIBERTY_XUI_WANT_X11 +#include <X11/Xatom.h> +#include <X11/Xlib.h> +#include <X11/keysym.h> +#include <X11/XKBlib.h> +#include <X11/Xft/Xft.h> +#endif // LIBERTY_XUI_WANT_X11 + +// The application needs to implement these. +static void app_quit (void); +static void app_layout (void); +static bool app_process_termo_event (termo_key_t *event); +static bool app_process_mouse (termo_mouse_event_t type, + int x, int y, int button, int modifiers); +static bool app_on_insufficient_color (void); +static void app_on_clipboard_copy (const char *text); + +// This could be overridable, however thus far row_buffer and line_editor both +// depend on XUI being initialized. +static bool xui_is_character_in_locale (ucs4_t ch); + +// --- Utilities --------------------------------------------------------------- + +// Unlike poller_timers_get_current_time(), this has a hard dependency +// on _POSIX_TIMERS, and can be used with both realtime nad monotonic clocks. +static int64_t +clock_msec (clockid_t clock) +{ + struct timespec tp; + hard_assert (clock_gettime (clock, &tp) != -1); + return (int64_t) tp.tv_sec * 1000 + (int64_t) tp.tv_nsec / 1000000; +} + +// --- Configurable display attributes ----------------------------------------- + +struct attrs +{ + short fg; ///< Foreground colour index + short bg; ///< Background colour index + chtype attrs; ///< Other attributes +}; + +/// Decode attributes in the value using a subset of the git config format, +/// ignoring all errors since it doesn't affect functionality +static struct attrs +attrs_decode (const char *value) +{ + struct strv v = strv_make (); + cstr_split (value, " ", true, &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 + } + strv_free (&v); + return attrs; +} + +// --- Line editor ------------------------------------------------------------- + +enum line_editor_action +{ + LINE_EDITOR_B_CHAR, ///< Go back a character + LINE_EDITOR_F_CHAR, ///< Go forward a character + LINE_EDITOR_B_WORD, ///< Go back a word + LINE_EDITOR_F_WORD, ///< Go forward a word + LINE_EDITOR_HOME, ///< Go to start of line + LINE_EDITOR_END, ///< Go to end of line + + LINE_EDITOR_UPCASE_WORD, ///< Convert word to uppercase + LINE_EDITOR_DOWNCASE_WORD, ///< Convert word to lowercase + LINE_EDITOR_CAPITALIZE_WORD, ///< Capitalize word + + LINE_EDITOR_B_DELETE, ///< Delete last character + LINE_EDITOR_F_DELETE, ///< Delete next character + LINE_EDITOR_B_KILL_WORD, ///< Delete last word + LINE_EDITOR_B_KILL_LINE, ///< Delete everything up to BOL + LINE_EDITOR_F_KILL_LINE, ///< Delete everything up to EOL +}; + +struct line_editor +{ + int point; ///< Caret index into line data + ucs4_t *line; ///< Line data, 0-terminated + int *w; ///< Codepoint widths, 0-terminated + size_t len; ///< Editor length + size_t alloc; ///< Editor allocated + char prompt; ///< Prompt character + + void (*on_changed) (void); ///< Callback on text change + void (*on_end) (bool); ///< Callback on abort +}; + +static void +line_editor_free (struct line_editor *self) +{ + free (self->line); + free (self->w); +} + +/// Notify whomever invoked the editor that it's been either confirmed or +/// cancelled and clean up editor state +static void +line_editor_abort (struct line_editor *self, bool status) +{ + self->on_end (status); + self->on_changed = NULL; + + free (self->line); + self->line = NULL; + free (self->w); + self->w = NULL; + self->alloc = 0; + self->len = 0; + self->point = 0; + self->prompt = 0; +} + +/// Start the line editor; remember to fill in "change" and "end" callbacks +static void +line_editor_start (struct line_editor *self, char prompt) +{ + self->alloc = 16; + self->line = xcalloc (sizeof *self->line, self->alloc); + self->w = xcalloc (sizeof *self->w, self->alloc); + self->len = 0; + self->point = 0; + self->prompt = prompt; +} + +static void +line_editor_changed (struct line_editor *self) +{ + self->line[self->len] = 0; + self->w[self->len] = 0; + + if (self->on_changed) + self->on_changed (); +} + +static void +line_editor_move (struct line_editor *self, int to, int from, int len) +{ + memmove (self->line + to, self->line + from, + sizeof *self->line * len); + memmove (self->w + to, self->w + from, + sizeof *self->w * len); +} + +static void +line_editor_insert (struct line_editor *self, ucs4_t codepoint) +{ + while (self->alloc - self->len < 2 /* inserted + sentinel */) + { + self->alloc <<= 1; + self->line = xreallocarray + (self->line, sizeof *self->line, self->alloc); + self->w = xreallocarray + (self->w, sizeof *self->w, self->alloc); + } + + line_editor_move (self, self->point + 1, self->point, + self->len - self->point); + self->line[self->point] = codepoint; + self->w[self->point] = xui_is_character_in_locale (codepoint) + ? uc_width (codepoint, locale_charset ()) + : 1 /* the replacement question mark */; + + self->point++; + self->len++; + line_editor_changed (self); +} + +static bool +line_editor_action (struct line_editor *self, enum line_editor_action action) +{ + switch (action) + { + default: + return soft_assert (!"unknown line editor action"); + + case LINE_EDITOR_B_CHAR: + if (self->point < 1) + return false; + do self->point--; + while (self->point > 0 + && !self->w[self->point]); + return true; + case LINE_EDITOR_F_CHAR: + if (self->point + 1 > (int) self->len) + return false; + do self->point++; + while (self->point < (int) self->len + && !self->w[self->point]); + return true; + case LINE_EDITOR_B_WORD: + { + if (self->point < 1) + return false; + int i = self->point; + while (i && self->line[--i] == ' '); + while (i-- && self->line[i] != ' '); + self->point = ++i; + return true; + } + case LINE_EDITOR_F_WORD: + { + if (self->point + 1 > (int) self->len) + return false; + int i = self->point; + while (i < (int) self->len && self->line[i] == ' ') i++; + while (i < (int) self->len && self->line[i] != ' ') i++; + self->point = i; + return true; + } + case LINE_EDITOR_HOME: + self->point = 0; + return true; + case LINE_EDITOR_END: + self->point = self->len; + return true; + + case LINE_EDITOR_UPCASE_WORD: + { + int i = self->point; + for (; i < (int) self->len && self->line[i] == ' '; i++); + for (; i < (int) self->len && self->line[i] != ' '; i++) + self->line[i] = uc_toupper (self->line[i]); + self->point = i; + line_editor_changed (self); + return true; + } + case LINE_EDITOR_DOWNCASE_WORD: + { + int i = self->point; + for (; i < (int) self->len && self->line[i] == ' '; i++); + for (; i < (int) self->len && self->line[i] != ' '; i++) + self->line[i] = uc_tolower (self->line[i]); + self->point = i; + line_editor_changed (self); + return true; + } + case LINE_EDITOR_CAPITALIZE_WORD: + { + int i = self->point; + ucs4_t (*converter) (ucs4_t) = uc_totitle; + for (; i < (int) self->len && self->line[i] == ' '; i++); + for (; i < (int) self->len && self->line[i] != ' '; i++) + { + self->line[i] = converter (self->line[i]); + converter = uc_tolower; + } + self->point = i; + line_editor_changed (self); + return true; + } + + case LINE_EDITOR_B_DELETE: + { + if (self->point < 1) + return false; + int len = 1; + while (self->point - len > 0 + && !self->w[self->point - len]) + len++; + line_editor_move (self, self->point - len, self->point, + self->len - self->point); + self->len -= len; + self->point -= len; + line_editor_changed (self); + return true; + } + case LINE_EDITOR_F_DELETE: + { + if (self->point + 1 > (int) self->len) + return false; + int len = 1; + while (self->point + len < (int) self->len + && !self->w[self->point + len]) + len++; + self->len -= len; + line_editor_move (self, self->point, self->point + len, + self->len - self->point); + line_editor_changed (self); + return true; + } + case LINE_EDITOR_B_KILL_WORD: + { + if (self->point < 1) + return false; + + int i = self->point; + while (i && self->line[--i] == ' '); + while (i-- && self->line[i] != ' '); + i++; + + line_editor_move (self, i, self->point, (self->len - self->point)); + self->len -= self->point - i; + self->point = i; + line_editor_changed (self); + return true; + } + case LINE_EDITOR_B_KILL_LINE: + self->len -= self->point; + line_editor_move (self, 0, self->point, self->len); + self->point = 0; + line_editor_changed (self); + return true; + case LINE_EDITOR_F_KILL_LINE: + self->len = self->point; + line_editor_changed (self); + return true; + } +} + +// --- Terminal output --------------------------------------------------------- + +// Necessary abstraction to simplify aligned, formatted character output + +struct row_char +{ + ucs4_t c; ///< Unicode codepoint + chtype attrs; ///< Special attributes + int width; ///< How many cells this takes +}; + +struct row_buffer +{ + ARRAY (struct row_char, chars) ///< Characters + int total_width; ///< Total width of all characters +}; + +static struct row_buffer +row_buffer_make (void) +{ + struct row_buffer self = {}; + ARRAY_INIT_SIZED (self.chars, 256); + return self; +} + +static void +row_buffer_free (struct row_buffer *self) +{ + free (self->chars); +} + +static void +row_buffer_append_c (struct row_buffer *self, ucs4_t c, chtype attrs) +{ + struct row_char current = { .attrs = attrs, .c = c }; + struct row_char invalid = { .attrs = attrs, .c = '?', .width = 1 }; + + current.width = uc_width (current.c, locale_charset ()); + if (current.width < 0 || !xui_is_character_in_locale (current.c)) + current = invalid; + + ARRAY_RESERVE (self->chars, 1); + self->chars[self->chars_len++] = current; + self->total_width += current.width; +} + +/// 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 (); + + // Note that this function is a hotspot, try to keep it decently fast + struct row_char current = { .attrs = attrs }; + struct row_char invalid = { .attrs = attrs, .c = '?', .width = 1 }; + const uint8_t *next = (const uint8_t *) str; + while ((next = u8_next (¤t.c, next))) + { + current.width = uc_width (current.c, encoding); + if (current.width < 0 || !xui_is_character_in_locale (current.c)) + current = invalid; + + ARRAY_RESERVE (self->chars, 1); + self->chars[self->chars_len++] = current; + self->total_width += current.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_len && made < space) + made += self->chars[--self->chars_len].width; + self->total_width -= made; + return made; +} + +static void +row_buffer_space (struct row_buffer *self, int width, chtype attrs) +{ + if (width < 0) + return; + + ARRAY_RESERVE (self->chars, (size_t) width); + + struct row_char space = { .attrs = attrs, .c = ' ', .width = 1 }; + self->total_width += width; + while (width-- > 0) + self->chars[self->chars_len++] = space; +} + +static void +row_buffer_ellipsis (struct row_buffer *self, int target) +{ + if (self->total_width <= target + || !row_buffer_pop_cells (self, self->total_width - target)) + return; + + // We use attributes from the last character we've removed, + // assuming that we don't shrink the array (and there's no real need) + ucs4_t ellipsis = 0x2026; // … + if (xui_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, "…", self->chars[self->chars_len].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, "...", self->chars[self->chars_len].attrs); + } +} + +static void +row_buffer_align (struct row_buffer *self, int target, chtype attrs) +{ + row_buffer_ellipsis (self, target); + row_buffer_space (self, target - self->total_width, attrs); +} + +static void +row_buffer_print (uint32_t *ucs4, chtype attrs) +{ + // This assumes that we can reset the attribute set without consequences + char *str = u32_strconv_to_locale (ucs4); + if (str) + { + attrset (attrs); + addstr (str); + attrset (0); + free (str); + } +} + +static void +row_buffer_flush (struct row_buffer *self) +{ + if (!self->chars_len) + return; + + // We only NUL-terminate the chunks because of the libunistring API + uint32_t chunk[self->chars_len + 1], *insertion_point = chunk; + for (size_t i = 0; i < self->chars_len; i++) + { + struct row_char *iter = self->chars + i; + if (i && iter[0].attrs != iter[-1].attrs) + { + row_buffer_print (chunk, iter[-1].attrs); + insertion_point = chunk; + } + *insertion_point++ = iter->c; + *insertion_point = 0; + } + row_buffer_print (chunk, self->chars[self->chars_len - 1].attrs); +} + +// --- XUI --------------------------------------------------------------------- + +struct widget; + +/// Draw a widget on the window +typedef void (*widget_render_fn) (struct widget *self); + +/// The widget has been placed +typedef void (*widget_allocated_fn) (struct widget *self); + +/// Extended attributes +enum { XUI_ATTR_MONOSPACE = 1 << 0 }; + +/// A minimal abstraction appropriate for both TUI and GUI widgets. +/// Units for the widget's region are frontend-specific. +/// Having this as a linked list simplifies layouting and memory management. +struct widget +{ + LIST_HEADER (struct widget) + + int x; ///< X coordinate + int y; ///< Y coordinate + int width; ///< Width, initialized by UI methods + int height; ///< Height, initialized by UI methods + + widget_render_fn on_render; ///< Render callback + widget_allocated_fn on_allocated; ///< Allocation callback + struct widget *children; ///< Child widgets of containers + chtype attrs; ///< Rendition, in Curses terms + unsigned extended_attrs; ///< XUI-specific attributes + + int id; ///< Post-layouting identification + int userdata; ///< Action ID/Tab index/... + char text[]; ///< Any text label +}; + +static void +widget_destroy (struct widget *self) +{ + LIST_FOR_EACH (struct widget, w, self->children) + widget_destroy (w); + free (self); +} + +static void +widget_move (struct widget *w, int dx, int dy) +{ + w->x += dx; + w->y += dy; + LIST_FOR_EACH (struct widget, child, w->children) + widget_move (child, dx, dy); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +struct ui +{ + struct widget *(*padding) + (chtype attrs, float width, float height); + struct widget *(*label) + (chtype attrs, unsigned extended, const char *label); + + void (*render) (void); + void (*flip) (void); + void (*winch) (void); + void (*destroy) (void); +}; + +#ifdef LIBERTY_XUI_WANT_X11 + +/// Wraps Xft fonts into a linked list with fallbacks. +struct x11_font_link +{ + struct x11_font_link *next; + XftFont *font; +}; + +enum +{ + X11_FONT_BOLD = 1 << 0, + X11_FONT_ITALIC = 1 << 1, + X11_FONT_MONOSPACE = 1 << 2, +}; + +struct x11_font +{ + struct x11_font *next; ///< Next in a linked list + + struct x11_font_link *list; ///< Fonts of varying Unicode coverage + unsigned style; ///< X11_FONT_* flags + FcPattern *pattern; ///< Original unsubstituted pattern + FcCharSet *unavailable; ///< Couldn't find a font for these +}; + +#endif // LIBERTY_XUI_WANT_X11 + +struct xui +{ + struct poller_idle refresh_event; ///< Refresh the window's contents + struct poller_idle flip_event; ///< Draw rendered widgets on screen + + // User interface: + + struct ui *ui; ///< User interface interface + struct widget *widgets; ///< Layouted widgets + int width; ///< Window width + int height; ///< Window height + int hunit; ///< Horizontal unit + int vunit; ///< Vertical unit + bool focused; ///< Whether the window has focus + + // Terminal: + + termo_t *tk; ///< termo handle (TUI/X11) + struct poller_fd tty_event; ///< Terminal input event + struct poller_timer tk_timer; ///< termo timeout timer + bool locale_is_utf8; ///< The locale is Unicode + + // X11: + +#ifdef LIBERTY_XUI_WANT_X11 + XIM x11_im; ///< Input method + XIC x11_ic; ///< Input method context + Display *dpy; ///< X display handle + struct poller_fd x11_event; ///< X11 events on wire + struct poller_idle xpending_event; ///< X11 events possibly in I/O queues + int xkb_base_event_code; ///< Xkb base event code + Window x11_window; ///< Application window + Pixmap x11_pixmap; ///< Off-screen bitmap + Region x11_clip; ///< Invalidated region + Picture x11_pixmap_picture; ///< XRender wrap for x11_pixmap + XftDraw *xft_draw; ///< Xft rendering context + struct x11_font *xft_fonts; ///< Font collection + char *x11_selection; ///< CLIPBOARD selection + + const char *x11_fontname; ///< Fontconfig font name + const char *x11_fontname_monospace; ///< Fontconfig monospace font name + XRenderColor *x_fg; ///< Foreground per attribute + XRenderColor *x_bg; ///< Background per attribute +#endif // LIBERTY_XUI_WANT_X11 +} +g_xui; + +static void +xui_invalidate (void) +{ + poller_idle_set (&g_xui.refresh_event); +} + +static bool +xui_process_termo_event (termo_key_t *event) +{ + if (event->type == TERMO_TYPE_FOCUS) + g_xui.focused = !!event->code.focused; + return app_process_termo_event (event); +} + +// --- TUI --------------------------------------------------------------------- + +static void +tui_flush_buffer (struct widget *self, struct row_buffer *buf) +{ + move (self->y, self->x); + + int space = MIN (self->width, g_xui.width - self->x); + row_buffer_align (buf, space, self->attrs); + row_buffer_flush (buf); + row_buffer_free (buf); +} + +static void +tui_render_padding (struct widget *self) +{ + // TODO: This should work even for heights != 1. + struct row_buffer buf = row_buffer_make (); + tui_flush_buffer (self, &buf); +} + +static struct widget * +tui_make_padding (chtype attrs, float width, float height) +{ + struct widget *w = xcalloc (1, sizeof *w + 2); + w->text[0] = ' '; + w->on_render = tui_render_padding; + w->attrs = attrs; + w->width = width * 2; + w->height = height; + return w; +} + +static void +tui_render_label (struct widget *self) +{ + struct row_buffer buf = row_buffer_make (); + row_buffer_append (&buf, self->text, self->attrs); + tui_flush_buffer (self, &buf); +} + +static struct widget * +tui_make_label (chtype attrs, unsigned extended, const char *label) +{ + (void) extended; + + size_t len = strlen (label); + struct widget *w = xcalloc (1, sizeof *w + len + 1); + w->on_render = tui_render_label; + w->attrs = attrs; + w->extended_attrs = extended; + memcpy (w->text, label, len); + + struct row_buffer buf = row_buffer_make (); + row_buffer_append (&buf, w->text, w->attrs); + w->width = buf.total_width; + w->height = 1; + row_buffer_free (&buf); + return w; +} + +static void +tui_render_widgets (struct widget *head) +{ + LIST_FOR_EACH (struct widget, w, head) + { + if (w->width < 0 || w->height < 0) + continue; + if (w->on_render) + w->on_render (w); + tui_render_widgets (w->children); + } +} + +static void +tui_render (void) +{ + erase (); + tui_render_widgets (g_xui.widgets); +} + +static void +tui_flip (void) +{ + // Curses handles double-buffering for us automatically. + refresh (); +} + +static void +tui_winch (void) +{ + // The standard endwin/refresh sequence makes the terminal flicker +#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 + + g_xui.width = COLS; + g_xui.height = LINES; + xui_invalidate (); +} + +static void +tui_destroy (void) +{ + endwin (); +} + +static struct ui tui_ui = +{ + .padding = tui_make_padding, + .label = tui_make_label, + + .render = tui_render, + .flip = tui_flip, + .winch = tui_winch, + .destroy = tui_destroy, +}; + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +tui_on_tty_event (termo_key_t *event, int64_t event_ts) +{ + // Simple double click detection via release--press delay, only a bit + // complicated by the fact that we don't know what's being released + static termo_key_t last_event; + static int64_t last_event_ts; + static int last_button; + + int y, x, button, y_last, x_last, modifiers = 0; + termo_mouse_event_t type, type_last; + if (termo_interpret_mouse (g_xui.tk, event, &type, &button, &y, &x)) + { + if (termo_interpret_mouse + (g_xui.tk, &last_event, &type_last, NULL, &y_last, &x_last) + && event_ts - last_event_ts < 500 + && type_last == TERMO_MOUSE_RELEASE && type == TERMO_MOUSE_PRESS + && y_last == y && x_last == x && last_button == button) + { + modifiers |= XUI_KEYMOD_DOUBLE_CLICK; + // Prevent interpreting triple clicks as two double clicks. + last_button = 0; + } + else if (type == TERMO_MOUSE_PRESS) + last_button = button; + + if (!app_process_mouse (type, x, y, button, modifiers)) + beep (); + } + else if (!xui_process_termo_event (event)) + beep (); + + last_event = *event; + last_event_ts = event_ts; +} + +static void +tui_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_xui.tk_timer); + termo_advisereadable (g_xui.tk); + + termo_key_t event = {}; + int64_t event_ts = clock_msec (CLOCK_BEST); + termo_result_t res; + while ((res = termo_getkey (g_xui.tk, &event)) == TERMO_RES_KEY) + tui_on_tty_event (&event, event_ts); + + if (res == TERMO_RES_AGAIN) + poller_timer_set (&g_xui.tk_timer, termo_get_waittime (g_xui.tk)); + else if (res == TERMO_RES_ERROR || res == TERMO_RES_EOF) + app_quit (); +} + +static void +tui_on_key_timer (void *user_data) +{ + (void) user_data; + + termo_key_t event; + if (termo_getkey_force (g_xui.tk, &event) == TERMO_RES_KEY) + if (!xui_process_termo_event (&event)) + beep (); +} + +static void +tui_init (struct poller *poller, struct attrs *attrs, size_t attrs_len) +{ + (void) poller; + + poller_fd_set (&g_xui.tty_event, POLLIN); + if (!termo_start (g_xui.tk) || !initscr () || nonl () == ERR) + exit_fatal ("failed to set up the terminal"); + + termo_set_mouse_tracking_mode (g_xui.tk, TERMO_MOUSE_TRACKING_DRAG); + + curs_set (0); + + g_xui.ui = &tui_ui; + g_xui.width = COLS; + g_xui.height = LINES; + g_xui.vunit = 1; + g_xui.hunit = 1; + + // The application should fall back to something at least nearly colourless + if (start_color () == ERR + || use_default_colors () == ERR + || COLOR_PAIRS <= (int) attrs_len) + { + app_on_insufficient_color (); + return; + } + + for (size_t a = 0; a < attrs_len; a++) + { + if (attrs[a].fg >= -1 && attrs[a].bg >= -1 + && init_pair (a + 1, attrs[a].fg, attrs[a].bg) == OK) + attrs[a].attrs |= COLOR_PAIR (a + 1); + else if (app_on_insufficient_color ()) + return; + } +} + +// --- X11 --------------------------------------------------------------------- + +#ifdef LIBERTY_XUI_WANT_X11 + +static XRenderColor x11_default_fg = { .alpha = 0xffff }; +static XRenderColor x11_default_bg = { 0xffff, 0xffff, 0xffff, 0xffff }; +static XErrorHandler x11_default_error_handler; + +static struct x11_font_link * +x11_font_link_new (XftFont *font) +{ + struct x11_font_link *self = xcalloc (1, sizeof *self); + self->font = font; + return self; +} + +static void +x11_font_link_destroy (struct x11_font_link *self) +{ + XftFontClose (g_xui.dpy, self->font); + free (self); +} + +static struct x11_font_link * +x11_font_link_open (FcPattern *pattern) +{ + XftFont *font = XftFontOpenPattern (g_xui.dpy, pattern); + if (!font) + { + FcPatternDestroy (pattern); + return NULL; + } + return x11_font_link_new (font); +} + +static struct x11_font * +x11_font_open (unsigned style) +{ + FcPattern *pattern = (style & X11_FONT_MONOSPACE) + ? FcNameParse ((const FcChar8 *) g_xui.x11_fontname_monospace) + : FcNameParse ((const FcChar8 *) g_xui.x11_fontname); + if (style & X11_FONT_BOLD) + FcPatternAdd (pattern, FC_STYLE, (FcValue) { + .type = FcTypeString, .u.s = (FcChar8 *) "Bold" }, FcFalse); + if (style & X11_FONT_ITALIC) + FcPatternAdd (pattern, FC_STYLE, (FcValue) { + .type = FcTypeString, .u.s = (FcChar8 *) "Italic" }, FcFalse); + + FcPattern *substituted = FcPatternDuplicate (pattern); + FcConfigSubstitute (NULL, substituted, FcMatchPattern); + + FcResult result = 0; + FcPattern *match = XftFontMatch (g_xui.dpy, + DefaultScreen (g_xui.dpy), substituted, &result); + FcPatternDestroy (substituted); + struct x11_font_link *link = NULL; + if (!match || !(link = x11_font_link_open (match))) + { + FcPatternDestroy (pattern); + return NULL; + } + + struct x11_font *self = xcalloc (1, sizeof *self); + self->list = link; + self->style = style; + self->pattern = pattern; + self->unavailable = FcCharSetCreate (); + return self; +} + +static void +x11_font_destroy (struct x11_font *self) +{ + FcPatternDestroy (self->pattern); + FcCharSetDestroy (self->unavailable); + LIST_FOR_EACH (struct x11_font_link, iter, self->list) + x11_font_link_destroy (iter); + free (self); + +} + +/// Find or instantiate a font that can render the character given by cp. +static XftFont * +x11_font_cover_codepoint (struct x11_font *self, ucs4_t cp) +{ + if (FcCharSetHasChar (self->unavailable, cp)) + return self->list->font; + + struct x11_font_link **used = &self->list; + for (; *used; used = &(*used)->next) + if (XftCharExists (g_xui.dpy, (*used)->font, cp)) + return (*used)->font; + + FcCharSet *set = FcCharSetCreate (); + FcCharSetAddChar (set, cp); + FcPattern *needle = FcPatternDuplicate (self->pattern); + FcPatternAddCharSet (needle, FC_CHARSET, set); + FcConfigSubstitute (NULL, needle, FcMatchPattern); + + FcResult result = 0; + FcPattern *match + = XftFontMatch (g_xui.dpy, DefaultScreen (g_xui.dpy), needle, &result); + FcCharSetDestroy (set); + FcPatternDestroy (needle); + if (!match) + goto fail; + + struct x11_font_link *new = x11_font_link_open (match); + if (!new) + goto fail; + + // The reverse may happen simply due to race conditions. + if (XftCharExists (g_xui.dpy, new->font, cp)) + return (*used = new)->font; + + x11_font_link_destroy (new); +fail: + FcCharSetAddChar (self->unavailable, cp); + return self->list->font; +} + +// TODO: Perhaps produce an array of FT_UInt glyph indexes, mainly so that +// x11_font_{hadvance,draw,render}() can use the same data, through the use +// of a new function that collects the spans in a data structure. +static size_t +x11_font_span (struct x11_font *self, const uint8_t *text, XftFont **font) +{ + hard_assert (self->list != NULL); + + // Xft similarly just stops on invalid UTF-8. + ucs4_t cp = 0; + const uint8_t *p = text; + if (!(p = u8_next (&cp, p))) + return 0; + + *font = x11_font_cover_codepoint (self, cp); + for (const uint8_t *end = NULL; (end = u8_next (&cp, p)); p = end) + { + if (x11_font_cover_codepoint (self, cp) != *font) + break; + } + return p - text; +} + +static int +x11_font_draw (struct x11_font *self, XftColor *color, int x, int y, + const char *text) +{ + int advance = 0; + size_t len = 0; + XftFont *font = NULL; + while ((len = x11_font_span (self, (const uint8_t *) text, &font))) + { + if (color) + { + XftDrawStringUtf8 (g_xui.xft_draw, color, font, + x + advance, y + self->list->font->ascent, + (const FcChar8 *) text, len); + } + + XGlyphInfo extents = {}; + XftTextExtentsUtf8 (g_xui.dpy, + font, (const FcChar8 *) text, len, &extents); + text += len; + advance += extents.xOff; + } + return advance; +} + +static int +x11_font_hadvance (struct x11_font *self, const char *text) +{ + return x11_font_draw (self, NULL, 0, 0, text); +} + +static int +x11_font_render (struct x11_font *self, int op, Picture src, int srcx, int srcy, + int x, int y, const char *text) +{ + int advance = 0; + size_t len = 0; + XftFont *font = NULL; + while ((len = x11_font_span (self, (const uint8_t *) text, &font))) + { + if (src) + { + XftTextRenderUtf8 (g_xui.dpy, + op, src, font, g_xui.x11_pixmap_picture, + srcx, srcy, x + advance, y + self->list->font->ascent, + (const FcChar8 *) text, len); + } + + XGlyphInfo extents = {}; + XftTextExtentsUtf8 (g_xui.dpy, + font, (const FcChar8 *) text, len, &extents); + text += len; + advance += extents.xOff; + } + return advance; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static struct x11_font * +x11_widget_font (struct widget *self) +{ + unsigned style = 0; + if (self->attrs & A_BOLD) + style |= X11_FONT_BOLD; + if (self->attrs & A_ITALIC) + style |= X11_FONT_ITALIC; + if (self->extended_attrs & XUI_ATTR_MONOSPACE) + style |= X11_FONT_MONOSPACE; + + struct x11_font **font = &g_xui.xft_fonts; + for (; *font; font = &(*font)->next) + if ((*font)->style == style) + return *font; + if ((*font = x11_font_open (style))) + return *font; + + // But FontConfig has a tendency to always return something. + return g_xui.xft_fonts; +} + +static XRenderColor * +x11_fg_attrs (chtype attrs) +{ + int pair = PAIR_NUMBER (attrs); + if (!pair--) + return &x11_default_fg; + return (attrs & A_REVERSE) ? &g_xui.x_bg[pair] : &g_xui.x_fg[pair]; +} + +static XRenderColor * +x11_fg (struct widget *self) +{ + return x11_fg_attrs (self->attrs); +} + +static XRenderColor * +x11_bg_attrs (chtype attrs) +{ + int pair = PAIR_NUMBER (attrs); + if (!pair--) + return &x11_default_bg; + return (attrs & A_REVERSE) ? &g_xui.x_fg[pair] : &g_xui.x_bg[pair]; +} + +static XRenderColor * +x11_bg (struct widget *self) +{ + return x11_bg_attrs (self->attrs); +} + +static void +x11_render_padding (struct widget *self) +{ + if (PAIR_NUMBER (self->attrs)) + { + XRenderFillRectangle (g_xui.dpy, PictOpSrc, g_xui.x11_pixmap_picture, + x11_bg (self), self->x, self->y, self->width, self->height); + } + if (self->attrs & A_UNDERLINE) + { + XRenderFillRectangle (g_xui.dpy, PictOpSrc, g_xui.x11_pixmap_picture, + x11_fg (self), self->x, self->y + self->height - 1, self->width, 1); + } +} + +static struct widget * +x11_make_padding (chtype attrs, float width, float height) +{ + struct widget *w = xcalloc (1, sizeof *w + 2); + w->text[0] = ' '; + w->on_render = x11_render_padding; + w->attrs = attrs; + w->width = g_xui.vunit * width; + w->height = g_xui.vunit * height; + return w; +} + +static void +x11_render_label (struct widget *self) +{ + x11_render_padding (self); + + int space = MIN (self->width, g_xui.width - self->x); + if (space <= 0) + return; + + // TODO: Try to avoid re-measuring on each render. + struct x11_font *font = x11_widget_font (self); + int advance = x11_font_hadvance (font, self->text); + if (advance <= space) + { + XftColor color = { .color = *x11_fg (self) }; + x11_font_draw (font, &color, self->x, self->y, self->text); + return; + } + + // XRender doesn't extend gradients beyond their end stops. + XRenderColor solid = *x11_fg (self), colors[3] = { solid, solid, solid }; + colors[2].alpha = 0; + + double portion = MIN (1, 2.0 * font->list->font->height / space); + XFixed stops[3] = { 0, XDoubleToFixed (1 - portion), XDoubleToFixed (1) }; + XLinearGradient gradient = { {}, { XDoubleToFixed (space), 0 } }; + + // Note that this masking is a very expensive operation. + Picture source = + XRenderCreateLinearGradient (g_xui.dpy, &gradient, stops, colors, 3); + x11_font_render (font, PictOpOver, source, -self->x, 0, self->x, self->y, + self->text); + XRenderFreePicture (g_xui.dpy, source); +} + +static struct widget * +x11_make_label (chtype attrs, unsigned extended, const char *label) +{ + // Xft renders combining marks by themselves, NFC improves it a bit. + // We'd have to use HarfBuzz to do this correctly. + size_t label_len = strlen (label) + 1, normalized_len = 0; + uint8_t *normalized = u8_normalize (UNINORM_NFC, + (const uint8_t *) label, label_len, NULL, &normalized_len); + if (!normalized) + { + normalized = memcpy (xmalloc (label_len), label, label_len); + normalized_len = label_len; + } + + struct widget *w = xcalloc (1, sizeof *w + normalized_len); + w->on_render = x11_render_label; + w->attrs = attrs; + w->extended_attrs = extended; + memcpy (w->text, normalized, normalized_len); + free (normalized); + + struct x11_font *font = x11_widget_font (w); + w->width = x11_font_hadvance (font, w->text); + w->height = font->list->font->height; + return w; +} + +static void +x11_render_widget (struct widget *w, const XRectangle *clip) +{ + if (w->width < 0 || w->height < 0) + return; + + // Children may set their own clips, so reset before each sibling. + // We need to go through Xft, or XftTextRenderUtf8() might skip glyphs. + if (clip) + XftDrawSetClipRectangles (g_xui.xft_draw, 0, 0, clip, 1); + else + XftDrawSetClip (g_xui.xft_draw, None); + + if (w->on_render) + w->on_render (w); + + // We set clips on containers, not on individual widgets. + XRectangle subclip = { w->x, w->y, w->width, w->height }; + if (clip) + { + int x1 = MAX (clip->x, w->x); + int y1 = MAX (clip->y, w->y); + int x2 = MIN (clip->x + clip->width, w->x + w->width); + int y2 = MIN (clip->y + clip->height, w->y + w->height); + if (x1 >= x2 || y1 >= y2) + return; + + subclip.x = x1; + subclip.y = y1; + subclip.width = x2 - x1; + subclip.height = y2 - y1; + } + + LIST_FOR_EACH (struct widget, child, w->children) + x11_render_widget (child, &subclip); +} + +static void +x11_render (void) +{ + XRenderFillRectangle (g_xui.dpy, PictOpSrc, g_xui.x11_pixmap_picture, + &x11_default_bg, 0, 0, g_xui.width, g_xui.height); + + LIST_FOR_EACH (struct widget, w, g_xui.widgets) + x11_render_widget (w, NULL); + + XRectangle r = { 0, 0, g_xui.width, g_xui.height }; + XUnionRectWithRegion (&r, g_xui.x11_clip, g_xui.x11_clip); + poller_idle_set (&g_xui.xpending_event); +} + +static void +x11_flip (void) +{ + // This exercise in futility doesn't seem to affect CPU usage much. + XRectangle r = {}; + XClipBox (g_xui.x11_clip, &r); + XCopyArea (g_xui.dpy, g_xui.x11_pixmap, g_xui.x11_window, + DefaultGC (g_xui.dpy, DefaultScreen (g_xui.dpy)), + r.x, r.y, r.width, r.height, r.x, r.y); + + XSubtractRegion (g_xui.x11_clip, g_xui.x11_clip, g_xui.x11_clip); + poller_idle_set (&g_xui.xpending_event); +} + +static void +x11_destroy (void) +{ + XDestroyIC (g_xui.x11_ic); + XCloseIM (g_xui.x11_im); + XDestroyRegion (g_xui.x11_clip); + XDestroyWindow (g_xui.dpy, g_xui.x11_window); + XRenderFreePicture (g_xui.dpy, g_xui.x11_pixmap_picture); + XFreePixmap (g_xui.dpy, g_xui.x11_pixmap); + XftDrawDestroy (g_xui.xft_draw); + LIST_FOR_EACH (struct x11_font, font, g_xui.xft_fonts) + x11_font_destroy (font); + cstr_set (&g_xui.x11_selection, NULL); + + free (g_xui.x_fg); + free (g_xui.x_bg); + + poller_fd_reset (&g_xui.x11_event); + XCloseDisplay (g_xui.dpy); + + // Xft hooks called in XCloseDisplay() don't clean up everything. + FcFini (); +} + +static struct ui x11_ui = +{ + .padding = x11_make_padding, + .label = x11_make_label, + + .render = x11_render, + .flip = x11_flip, + .destroy = x11_destroy, +}; + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static termo_sym_t +x11_convert_keysym (KeySym keysym) +{ + // Leaving out TERMO_TYPE_FUNCTION, TERMO_SYM_DEL (N/A), + // and TERMO_SYM_SPACE (governed by TERMO_FLAG_SPACESYMBOL, not in use). + switch (keysym) + { + case XK_BackSpace: return TERMO_SYM_BACKSPACE; + case XK_Tab: return TERMO_SYM_TAB; + case XK_ISO_Left_Tab: return TERMO_SYM_TAB; + case XK_Return: return TERMO_SYM_ENTER; + case XK_Escape: return TERMO_SYM_ESCAPE; + + case XK_Up: return TERMO_SYM_UP; + case XK_Down: return TERMO_SYM_DOWN; + case XK_Left: return TERMO_SYM_LEFT; + case XK_Right: return TERMO_SYM_RIGHT; + case XK_Begin: return TERMO_SYM_BEGIN; + case XK_Find: return TERMO_SYM_FIND; + case XK_Insert: return TERMO_SYM_INSERT; + case XK_Delete: return TERMO_SYM_DELETE; + case XK_Select: return TERMO_SYM_SELECT; + case XK_Page_Up: return TERMO_SYM_PAGEUP; + case XK_Page_Down: return TERMO_SYM_PAGEDOWN; + case XK_Home: return TERMO_SYM_HOME; + case XK_End: return TERMO_SYM_END; + + case XK_Cancel: return TERMO_SYM_CANCEL; + case XK_Clear: return TERMO_SYM_CLEAR; + // TERMO_SYM_CLOSE + // TERMO_SYM_COMMAND + // TERMO_SYM_COPY + // TERMO_SYM_EXIT + case XK_Help: return TERMO_SYM_HELP; + // TERMO_SYM_MARK + // TERMO_SYM_MESSAGE + // TERMO_SYM_MOVE + // TERMO_SYM_OPEN + // TERMO_SYM_OPTIONS + case XK_Print: return TERMO_SYM_PRINT; + case XK_Redo: return TERMO_SYM_REDO; + // TERMO_SYM_REFERENCE + // TERMO_SYM_REFRESH + // TERMO_SYM_REPLACE + // TERMO_SYM_RESTART + // TERMO_SYM_RESUME + // TERMO_SYM_SAVE + // TERMO_SYM_SUSPEND + case XK_Undo: return TERMO_SYM_UNDO; + + case XK_KP_0: return TERMO_SYM_KP0; + case XK_KP_1: return TERMO_SYM_KP1; + case XK_KP_2: return TERMO_SYM_KP2; + case XK_KP_3: return TERMO_SYM_KP3; + case XK_KP_4: return TERMO_SYM_KP4; + case XK_KP_5: return TERMO_SYM_KP5; + case XK_KP_6: return TERMO_SYM_KP6; + case XK_KP_7: return TERMO_SYM_KP7; + case XK_KP_8: return TERMO_SYM_KP8; + case XK_KP_9: return TERMO_SYM_KP9; + case XK_KP_Enter: return TERMO_SYM_KPENTER; + case XK_KP_Add: return TERMO_SYM_KPPLUS; + case XK_KP_Subtract: return TERMO_SYM_KPMINUS; + case XK_KP_Multiply: return TERMO_SYM_KPMULT; + case XK_KP_Divide: return TERMO_SYM_KPDIV; + case XK_KP_Separator: return TERMO_SYM_KPCOMMA; + case XK_KP_Decimal: return TERMO_SYM_KPPERIOD; + case XK_KP_Equal: return TERMO_SYM_KPEQUALS; + } + return TERMO_SYM_UNKNOWN; +} + +static bool +on_x11_keypress (XEvent *e) +{ + // A kibibyte long buffer will have to suffice for anyone. + XKeyEvent *ev = &e->xkey; + char buf[1 << 10] = {}, *p = buf; + KeySym keysym = None; + Status status = 0; + int len = Xutf8LookupString + (g_xui.x11_ic, ev, buf, sizeof buf, &keysym, &status); + if (status == XBufferOverflow) + print_warning ("input method overflow"); + + termo_key_t key = {}; + if (ev->state & ShiftMask) + key.modifiers |= TERMO_KEYMOD_SHIFT; + if (ev->state & ControlMask) + key.modifiers |= TERMO_KEYMOD_CTRL; + if (ev->state & Mod1Mask) + key.modifiers |= TERMO_KEYMOD_ALT; + + if (keysym >= XK_F1 && keysym <= XK_F35) + { + key.type = TERMO_TYPE_FUNCTION; + key.code.number = 1 + keysym - XK_F1; + return xui_process_termo_event (&key); + } + if ((key.code.sym = x11_convert_keysym (keysym)) != TERMO_SYM_UNKNOWN) + { + key.type = TERMO_TYPE_KEYSYM; + return xui_process_termo_event (&key); + } + + bool result = true; + if (len) + { + key.type = TERMO_TYPE_KEY; + key.modifiers &= ~TERMO_KEYMOD_SHIFT; + + int32_t cp = 0; + struct utf8_iter iter = { .s = buf, .len = len }; + size_t cp_len = 0; + while ((cp = utf8_iter_next (&iter, &cp_len)) >= 0) + { + termo_key_t k = key; + memcpy (k.multibyte, p, MIN (cp_len, sizeof k.multibyte - 1)); + p += cp_len; + + // This is all unfortunate, but probably in the right place. + if (!cp) + { + k.code.codepoint = ' '; + if (ev->state & ShiftMask) + k.modifiers |= TERMO_KEYMOD_SHIFT; + } + else if (cp >= 32) + k.code.codepoint = cp; + else if (ev->state & ShiftMask) + k.code.codepoint = cp + 64; + else + k.code.codepoint = cp + 96; + if (!xui_process_termo_event (&k)) + result = false; + } + } + return result; +} + +static void +x11_init_pixmap (void) +{ + int screen = DefaultScreen (g_xui.dpy); + g_xui.x11_pixmap = XCreatePixmap (g_xui.dpy, g_xui.x11_window, + g_xui.width, g_xui.height, DefaultDepth (g_xui.dpy, screen)); + + Visual *visual = DefaultVisual (g_xui.dpy, screen); + XRenderPictFormat *format = XRenderFindVisualFormat (g_xui.dpy, visual); + g_xui.x11_pixmap_picture + = XRenderCreatePicture (g_xui.dpy, g_xui.x11_pixmap, format, 0, NULL); +} + +static char * +x11_find_text (struct widget *list, int x, int y) +{ + struct widget *target = NULL; + LIST_FOR_EACH (struct widget, w, list) + if (x >= w->x && x < w->x + w->width + && y >= w->y && y < w->y + w->height) + target = w; + if (!target) + return NULL; + + char *result = x11_find_text (target->children, x, y); + if (result) + return result; + return xstrdup (target->text); +} + +// TODO: OSC 52 exists for terminals, so make it possible to enable that there. +static bool +x11_process_press (int x, int y, int button, int modifiers) +{ + if (button != Button3) + goto out; + + char *text = x11_find_text (g_xui.widgets, x, y); + if (!text || !*(cstr_strip_in_place (text, " \t"))) + { + free (text); + goto out; + } + + cstr_set (&g_xui.x11_selection, text); + XSetSelectionOwner (g_xui.dpy, XInternAtom (g_xui.dpy, "CLIPBOARD", False), + g_xui.x11_window, CurrentTime); + app_on_clipboard_copy (g_xui.x11_selection); + return true; + +out: + return app_process_mouse (TERMO_MOUSE_PRESS, x, y, button, modifiers); +} + +static int +x11_state_to_modifiers (unsigned int state) +{ + int modifiers = 0; + if (state & ShiftMask) modifiers |= TERMO_KEYMOD_SHIFT; + if (state & ControlMask) modifiers |= TERMO_KEYMOD_CTRL; + if (state & Mod1Mask) modifiers |= TERMO_KEYMOD_ALT; + return modifiers; +} + +static bool +on_x11_input_event (XEvent *ev) +{ + static XEvent last_press_event; + if (ev->type == KeyPress) + { + last_press_event = (XEvent) {}; + return on_x11_keypress (ev); + } + if (ev->type == MotionNotify) + { + return app_process_mouse (TERMO_MOUSE_DRAG, + ev->xmotion.x, ev->xmotion.y, 1 /* Button1MotionMask */, + x11_state_to_modifiers (ev->xmotion.state)); + } + + // This is nearly the same as tui_on_tty_event(). + int x = ev->xbutton.x, y = ev->xbutton.y; + unsigned int button = ev->xbutton.button; + int modifiers = x11_state_to_modifiers (ev->xbutton.state); + if (ev->type == ButtonPress + && ev->xbutton.time - last_press_event.xbutton.time < 500 + && abs (last_press_event.xbutton.x - x) < 5 + && abs (last_press_event.xbutton.y - y) < 5 + && last_press_event.xbutton.button == button) + { + modifiers |= XUI_KEYMOD_DOUBLE_CLICK; + // Prevent interpreting triple clicks as two double clicks. + last_press_event = (XEvent) {}; + } + else if (ev->type == ButtonPress) + last_press_event = *ev; + + if (ev->type == ButtonPress) + return x11_process_press (x, y, button, modifiers); + if (ev->type == ButtonRelease) + return app_process_mouse + (TERMO_MOUSE_RELEASE, x, y, button, modifiers); + return false; +} + +static void +on_x11_selection_request (XSelectionRequestEvent *ev) +{ + Atom xa_targets = XInternAtom (g_xui.dpy, "TARGETS", False); + Atom xa_compound_text = XInternAtom (g_xui.dpy, "COMPOUND_TEXT", False); + Atom xa_utf8 = XInternAtom (g_xui.dpy, "UTF8_STRING", False); + Atom targets[] = { xa_targets, XA_STRING, xa_compound_text, xa_utf8 }; + + XEvent response = {}; + bool ok = false; + Atom property = ev->property ? ev->property : ev->target; + if (!g_xui.x11_selection) + goto out; + + XICCEncodingStyle style = 0; + if ((ok = ev->target == xa_targets)) + { + XChangeProperty (g_xui.dpy, ev->requestor, property, + XA_ATOM, 32, PropModeReplace, + (const unsigned char *) targets, N_ELEMENTS (targets)); + goto out; + } + else if (ev->target == XA_STRING) + style = XStringStyle; + else if (ev->target == xa_compound_text) + style = XCompoundTextStyle; + else if (ev->target == xa_utf8) + style = XUTF8StringStyle; + else + goto out; + + // XXX: We let it crash us with BadLength, but we may, e.g., use INCR. + XTextProperty text = {}; + if ((ok = !Xutf8TextListToTextProperty + (g_xui.dpy, &g_xui.x11_selection, 1, style, &text))) + { + XChangeProperty (g_xui.dpy, ev->requestor, property, + text.encoding, text.format, PropModeReplace, + text.value, text.nitems); + } + XFree (text.value); + +out: + response.xselection.type = SelectionNotify; + // XXX: We should check it against the event causing XSetSelectionOwner(). + response.xselection.time = ev->time; + response.xselection.requestor = ev->requestor; + response.xselection.selection = ev->selection; + response.xselection.target = ev->target; + response.xselection.property = ok ? property : None; + XSendEvent (g_xui.dpy, ev->requestor, False, 0, &response); +} + +static void +on_x11_event (XEvent *ev) +{ + termo_key_t key = {}; + switch (ev->type) + { + case Expose: + { + XRectangle r = { ev->xexpose.x, ev->xexpose.y, + ev->xexpose.width, ev->xexpose.height }; + XUnionRectWithRegion (&r, g_xui.x11_clip, g_xui.x11_clip); + poller_idle_set (&g_xui.flip_event); + break; + } + case ConfigureNotify: + if (g_xui.width == ev->xconfigure.width + && g_xui.height == ev->xconfigure.height) + break; + + g_xui.width = ev->xconfigure.width; + g_xui.height = ev->xconfigure.height; + + XRenderFreePicture (g_xui.dpy, g_xui.x11_pixmap_picture); + XFreePixmap (g_xui.dpy, g_xui.x11_pixmap); + x11_init_pixmap (); + XftDrawChange (g_xui.xft_draw, g_xui.x11_pixmap); + xui_invalidate (); + break; + case SelectionRequest: + on_x11_selection_request (&ev->xselectionrequest); + break; + case SelectionClear: + cstr_set (&g_xui.x11_selection, NULL); + break; + // UnmapNotify can be received when restarting the window manager. + // Should this turn out to be unreliable (window not destroyed by WM + // upon closing), opt for the WM_DELETE_WINDOW protocol as well. + case DestroyNotify: + app_quit (); + break; + case FocusIn: + key.type = TERMO_TYPE_FOCUS; + key.code.focused = true; + xui_process_termo_event (&key); + break; + case FocusOut: + key.type = TERMO_TYPE_FOCUS; + key.code.focused = false; + xui_process_termo_event (&key); + break; + case KeyPress: + case ButtonPress: + case ButtonRelease: + case MotionNotify: + if (!on_x11_input_event (ev)) + XkbBell (g_xui.dpy, ev->xany.window, 0, None); + } +} + +static void +on_x11_pending (void *user_data) +{ + (void) user_data; + + XkbEvent ev; + while (XPending (g_xui.dpy)) + { + if (XNextEvent (g_xui.dpy, &ev.core)) + exit_fatal ("XNextEvent returned non-zero"); + if (XFilterEvent (&ev.core, None)) + continue; + + on_x11_event (&ev.core); + } + + poller_idle_reset (&g_xui.xpending_event); +} + +static void +on_x11_ready (const struct pollfd *pfd, void *user_data) +{ + (void) pfd; + on_x11_pending (user_data); +} + +static int +on_x11_error (Display *dpy, XErrorEvent *event) +{ + // Without opting for WM_DELETE_WINDOW, this window can become destroyed + // and hence invalid at any time. We don't use the Window much, + // so we should be fine ignoring these errors. + if ((event->error_code == BadWindow + && event->resourceid == g_xui.x11_window) + || (event->error_code == BadDrawable + && event->resourceid == g_xui.x11_window)) + return app_quit (), 0; + + // XXX: The simplest possible way of discarding selection management errors. + // XCB would be a small win here, but it is a curse at the same time. + if (event->error_code == BadWindow && event->resourceid != g_xui.x11_window) + return 0; + + return x11_default_error_handler (dpy, event); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static XRenderColor +x11_convert_color (int color) +{ + hard_assert (color >= 0 && color <= 255); + + static const uint16_t base[16] = + { + 0x000, 0x800, 0x080, 0x880, 0x008, 0x808, 0x088, 0xccc, + 0x888, 0xf00, 0x0f0, 0xff0, 0x00f, 0xf0f, 0x0ff, 0xfff, + }; + + XRenderColor c = { .alpha = 0xffff }; + if (color < 16) + { + c.red = 0x1111 * (base[color] >> 8); + c.green = 0x1111 * (0xf & (base[color] >> 4)); + c.blue = 0x1111 * (0xf & (base[color])); + } + else if (color >= 232) + c.red = c.green = c.blue = 0x0101 * (8 + (color - 232) * 10); + else + { + color -= 16; + + int r = color / 36; + int g = (color / 6) % 6; + int b = (color % 6); + c.red = 0x0101 * !!r * (55 + 40 * r); + c.green = 0x0101 * !!g * (55 + 40 * g); + c.blue = 0x0101 * !!b * (55 + 40 * b); + } + return c; +} + +static void +x11_init_attributes (struct attrs *attrs, size_t attrs_len) +{ + g_xui.x_fg = xcalloc (attrs_len, sizeof g_xui.x_fg[0]); + g_xui.x_bg = xcalloc (attrs_len, sizeof g_xui.x_bg[0]); + for (size_t a = 0; a < attrs_len; a++) + { + g_xui.x_fg[a] = x11_default_fg; + g_xui.x_bg[a] = x11_default_bg; + if (attrs[a].fg >= 256 || attrs[a].fg < -1 + || attrs[a].bg >= 256 || attrs[a].bg < -1) + continue; + + if (attrs[a].fg != -1) + g_xui.x_fg[a] = x11_convert_color (attrs[a].fg); + if (attrs[a].bg != -1) + g_xui.x_bg[a] = x11_convert_color (attrs[a].bg); + + attrs[a].attrs |= COLOR_PAIR (a + 1); + } +} + +static void +x11_init (struct poller *poller, struct attrs *app_attrs, size_t app_attrs_len) +{ + // https://tedyin.com/posts/a-brief-intro-to-linux-input-method-framework/ + if (!XSupportsLocale ()) + print_warning ("locale not supported by Xlib"); + XSetLocaleModifiers (""); + + if (!(g_xui.dpy = XkbOpenDisplay + (NULL, &g_xui.xkb_base_event_code, NULL, NULL, NULL, NULL))) + exit_fatal ("cannot open display"); + if (!XftDefaultHasRender (g_xui.dpy)) + exit_fatal ("XRender is not supported"); + if (!(g_xui.x11_im = XOpenIM (g_xui.dpy, NULL, NULL, NULL))) + exit_fatal ("failed to open an input method"); + + x11_default_error_handler = XSetErrorHandler (on_x11_error); + + set_cloexec (ConnectionNumber (g_xui.dpy)); + g_xui.x11_event = poller_fd_make (poller, ConnectionNumber (g_xui.dpy)); + g_xui.x11_event.dispatcher = on_x11_ready; + poller_fd_set (&g_xui.x11_event, POLLIN); + + // Whenever something causes Xlib to read its socket, it can make + // the I/O event above fail to trigger for whatever might have ended up + // in its queue. So always use this instead of XSync: + g_xui.xpending_event = poller_idle_make (poller); + g_xui.xpending_event.dispatcher = on_x11_pending; + poller_idle_set (&g_xui.xpending_event); + + x11_init_attributes (app_attrs, app_attrs_len); + + if (!FcInit ()) + print_warning ("Fontconfig initialization failed"); + if (!(g_xui.xft_fonts = x11_font_open (0))) + exit_fatal ("cannot open a font"); + + int screen = DefaultScreen (g_xui.dpy); + Colormap cmap = DefaultColormap (g_xui.dpy, screen); + XColor default_bg = + { + .red = x11_default_bg.red, + .green = x11_default_bg.green, + .blue = x11_default_bg.blue, + }; + if (!XAllocColor (g_xui.dpy, cmap, &default_bg)) + exit_fatal ("X11 setup failed"); + + XSetWindowAttributes attrs = + { + .event_mask = StructureNotifyMask | ExposureMask | FocusChangeMask + | KeyPressMask | ButtonPressMask | ButtonReleaseMask + | Button1MotionMask, + .bit_gravity = NorthWestGravity, + .background_pixel = default_bg.pixel, + }; + + // Approximate the average width of a character to half of the em unit. + g_xui.vunit = g_xui.xft_fonts->list->font->height; + g_xui.hunit = g_xui.vunit / 2; + // Base the window's size on the regular font size. + // Roughly trying to match the 80x24 default dimensions of terminals. + g_xui.height = 24 * g_xui.vunit; + g_xui.width = g_xui.height * 4 / 3; + + long im_event_mask = 0; + if (!XGetIMValues (g_xui.x11_im, XNFilterEvents, &im_event_mask, NULL)) + attrs.event_mask |= im_event_mask; + + Visual *visual = DefaultVisual (g_xui.dpy, screen); + g_xui.x11_window = XCreateWindow (g_xui.dpy, + RootWindow (g_xui.dpy, screen), 100, 100, + g_xui.width, g_xui.height, 0, CopyFromParent, InputOutput, visual, + CWEventMask | CWBackPixel | CWBitGravity, &attrs); + g_xui.x11_clip = XCreateRegion (); + + XTextProperty prop = {}; + char *name = PROGRAM_NAME; + if (!Xutf8TextListToTextProperty (g_xui.dpy, + &name, 1, XUTF8StringStyle, &prop)) + XSetWMName (g_xui.dpy, g_xui.x11_window, &prop); + XFree (prop.value); + + // TODO: It is possible to do, e.g., on-the-spot. + XIMStyle im_style = XIMPreeditNothing | XIMStatusNothing; + XIMStyles *im_styles = NULL; + bool im_style_found = false; + if (!XGetIMValues (g_xui.x11_im, XNQueryInputStyle, &im_styles, NULL) + && im_styles) + { + for (unsigned i = 0; i < im_styles->count_styles; i++) + im_style_found |= im_styles->supported_styles[i] == im_style; + XFree (im_styles); + } + if (!im_style_found) + print_warning ("failed to find the desired input method style"); + if (!(g_xui.x11_ic = XCreateIC (g_xui.x11_im, + XNInputStyle, im_style, + XNClientWindow, g_xui.x11_window, + NULL))) + exit_fatal ("failed to open an input context"); + + XSetICFocus (g_xui.x11_ic); + + x11_init_pixmap (); + g_xui.xft_draw = XftDrawCreate (g_xui.dpy, g_xui.x11_pixmap, visual, cmap); + g_xui.ui = &x11_ui; + + XMapWindow (g_xui.dpy, g_xui.x11_window); +} + +#endif // LIBERTY_XUI_WANT_X11 + +// --- Containers -------------------------------------------------------------- + +static void +xui_on_hbox_allocated (struct widget *self) +{ + int parts = 0, width = self->width; + LIST_FOR_EACH (struct widget, w, self->children) + { + if (w->width < 0) + parts -= w->width; + else + width -= w->width; + } + + int remaining = MAX (width, 0), + part_width = parts ? remaining / parts : 0; + struct widget *last = NULL; + LIST_FOR_EACH (struct widget, w, self->children) + { + w->height = self->height; + if (w->width < 0) + { + remaining -= (w->width *= -part_width); + last = w; + } + } + if (last) + last->width += remaining; + + int x = self->x, y = self->y; + LIST_FOR_EACH (struct widget, w, self->children) + { + widget_move (w, x - w->x, y - w->y); + x += w->width; + + if (w->on_allocated) + w->on_allocated (w); + } +} + +static struct widget * +xui_hbox (struct widget *head) +{ + struct widget *self = xcalloc (1, sizeof *self); + self->children = head; + self->on_allocated = xui_on_hbox_allocated; + + LIST_FOR_EACH (struct widget, w, head) + { + self->height = MAX (self->height, w->height); + self->width += MAX (0, w->width); + } + return self; +} + +static void +xui_on_vbox_allocated (struct widget *self) +{ + int parts = 0, height = self->height; + LIST_FOR_EACH (struct widget, w, self->children) + { + if (w->height < 0) + parts -= w->height; + else + height -= w->height; + } + + int remaining = MAX (height, 0), + part_height = parts ? remaining / parts : 0; + struct widget *last = NULL; + LIST_FOR_EACH (struct widget, w, self->children) + { + w->width = self->width; + if (w->height < 0) + { + remaining -= (w->height *= -part_height); + last = w; + } + } + if (last) + last->height += remaining; + + int x = self->x, y = self->y; + LIST_FOR_EACH (struct widget, w, self->children) + { + widget_move (w, x - w->x, y - w->y); + y += w->height; + + if (w->on_allocated) + w->on_allocated (w); + } +} + +static struct widget * +xui_vbox (struct widget *head) +{ + struct widget *self = xcalloc (1, sizeof *self); + self->children = head; + self->on_allocated = xui_on_vbox_allocated; + + LIST_FOR_EACH (struct widget, w, head) + { + self->width = MAX (self->width, w->width); + self->height += MAX (0, w->height); + } + return self; +} + +// --- XUI --------------------------------------------------------------------- + +static bool +xui_is_character_in_locale (ucs4_t ch) +{ + // Avoid the overhead joined with calling iconv() for all characters. + if (g_xui.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; +} + +static void +xui_on_flip (void *user_data) +{ + (void) user_data; + poller_idle_reset (&g_xui.flip_event); + + // Waste of time, and may cause X11 to render uninitialised pixmaps. + if (/*g.polling &&*/ !g_xui.refresh_event.active) + g_xui.ui->flip (); +} + +static void +xui_on_refresh (void *user_data) +{ + (void) user_data; + poller_idle_reset (&g_xui.refresh_event); + + LIST_FOR_EACH (struct widget, w, g_xui.widgets) + widget_destroy (w); + + g_xui.widgets = NULL; + app_layout (); + + // Keep whatever the application gave them, for flexibility. + LIST_FOR_EACH (struct widget, w, g_xui.widgets) + if (w->on_allocated) + w->on_allocated (w); + + g_xui.ui->render (); + poller_idle_set (&g_xui.flip_event); +} + +static void +xui_preinit (void) +{ + TERMO_CHECK_VERSION; + if (!(g_xui.tk = termo_new (STDIN_FILENO, NULL, TERMO_FLAG_NOSTART))) + exit_fatal ("failed to initialize termo"); + + // 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_xui.locale_is_utf8 = !strcasecmp_ascii (locale_charset (), "UTF-8"); + + // Presumably, although not necessarily; unsure if queryable at all. + g_xui.focused = true; + + // TODO: Try to use Gtk/FontName from the _XSETTINGS_S%d selection, + // as well as Net/DoubleClick*. See the XSETTINGS proposal for details. + // https://www.freedesktop.org/wiki/Specifications/XSettingsRegistry/ + // Note that this needs an X11 connection already. +#ifdef LIBERTY_XUI_WANT_X11 + g_xui.x11_fontname = "sans\\-serif-11"; + g_xui.x11_fontname_monospace = "monospace-11"; +#endif // LIBERTY_XUI_WANT_X11 +} + +static void +xui_start (struct poller *poller, + bool force_x11, struct attrs *attrs, size_t attrs_len) +{ + (void) force_x11; + + g_xui.refresh_event = poller_idle_make (poller); + g_xui.refresh_event.dispatcher = xui_on_refresh; + g_xui.flip_event = poller_idle_make (poller); + g_xui.flip_event.dispatcher = xui_on_flip; + + // Always initialized, but only activated with the TUI. + g_xui.tty_event = poller_fd_make (poller, STDIN_FILENO); + g_xui.tty_event.dispatcher = tui_on_tty_readable; + g_xui.tk_timer = poller_timer_make (poller); + g_xui.tk_timer.dispatcher = tui_on_key_timer; + +#ifdef LIBERTY_XUI_WANT_X11 + if (force_x11 || (!isatty (STDIN_FILENO) && getenv ("DISPLAY"))) + x11_init (poller, attrs, attrs_len); + else +#endif // LIBERTY_XUI_WANT_X11 + tui_init (poller, attrs, attrs_len); +} + +static void +xui_stop (void) +{ + poller_idle_reset (&g_xui.refresh_event); + poller_idle_reset (&g_xui.flip_event); + poller_fd_reset (&g_xui.tty_event); + poller_timer_reset (&g_xui.tk_timer); + + g_xui.ui->destroy (); + LIST_FOR_EACH (struct widget, w, g_xui.widgets) + widget_destroy (w); + + termo_destroy (g_xui.tk); +} diff --git a/tests/fuzz.c b/tests/fuzz.c index 74db020..1e3c995 100644 --- a/tests/fuzz.c +++ b/tests/fuzz.c @@ -32,13 +32,6 @@ #define LIBERTY_WANT_PROTO_MPD #include "../liberty.c" -#include "../liberty-tui.c" - -static bool -app_is_character_in_locale (ucs4_t ch) -{ - return ch < 128; -} // --- UTF-8 ------------------------------------------------------------------- @@ -211,19 +204,6 @@ test_config_item_parse (const uint8_t *data, size_t size) config_item_destroy (item); } -// --- TUI --------------------------------------------------------------------- - -static void -test_attrs_decode (const uint8_t *data, size_t size) -{ - struct str wrap = str_make (); - str_append_data (&wrap, data, size); - - attrs_decode (wrap.str); - - str_free (&wrap); -} - // --- MPD --------------------------------------------------------------------- static void @@ -266,7 +246,6 @@ LLVMFuzzerInitialize (int *argcp, char ***argvp) REGISTER (fcgi_parser_push) REGISTER (fcgi_nv_parser_push) REGISTER (config_item_parse) - REGISTER (attrs_decode) REGISTER (mpd_client_process_input) char **argv = *argvp, *option = "-test=", *name = NULL; |