mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-06 04:06:06 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/main.c
Daniel Eklöf f87d4f856a
main: mitigate screen flashes on slow client 
If a client writes to the PTY "too slow", we often end up flashing the
screen. This could for example be caused by a client first erasing a
line, then we render that frame, followed by the client updating the
just-erased line. When we render _that_ frame, it will be perceived as
a flash.

Mitigate this by trying to read client data again, after finishing
processing one batch, but before rendering.

To avoid hanging on client output (and never rendering anything),
limit this to at most 3 iterations. This may have to be tweaked.
2019-07-03 15:16:38 +02:00

1109 lines
33 KiB
C
Raw Blame History

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <locale.h>
#include <getopt.h>
#include <poll.h>
#include <errno.h>
#include <sys/ioctl.h>
//#include <termios.h>
#include <wayland-client.h>
#include <xdg-shell.h>
#define LOG_MODULE "main"
#define LOG_ENABLE_DBG 1
#include "log.h"
#include "font.h"
#include "shm.h"
#include "slave.h"
#include "terminal.h"
#include "vt.h"
#include "input.h"
#include "grid.h"
#define min(x, y) ((x) < (y) ? (x) : (y))
#define max(x, y) ((x) > (y) ? (x) : (y))
static const struct rgba default_foreground = {1.0, 1.0, 1.0, 1.0};
static const struct rgba default_background = {0.0, 0.0, 0.0, 1.0};
struct wayland {
struct wl_display *display;
struct wl_registry *registry;
struct wl_compositor *compositor;
struct wl_surface *surface;
struct wl_shm *shm;
struct wl_seat *seat;
struct wl_keyboard *keyboard;
struct xdg_wm_base *shell;
struct xdg_surface *xdg_surface;
struct xdg_toplevel *xdg_toplevel;
};
struct context {
bool quit;
cairo_scaled_font_t *fonts[4];
cairo_font_extents_t fextents;
int width;
int height;
struct wayland wl;
//struct grid grid;
struct terminal term;
bool frame_is_scheduled;
};
static void frame_callback(
void *data, struct wl_callback *wl_callback, uint32_t callback_data);
static const struct wl_callback_listener frame_listener = {
.done = &frame_callback,
};
static cairo_scaled_font_t *
attrs_to_font(struct context *c, const struct attributes *attrs)
{
int idx = attrs->italic << 1 | attrs->bold;
return c->fonts[idx];
}
struct glyph_sequence {
cairo_glyph_t glyphs[10000];
cairo_glyph_t *g;
int count;
struct attributes attrs;
struct rgba foreground;
};
static void
grid_render_update(struct context *c, struct buffer *buf, const struct damage *dmg)
{
LOG_DBG("damage: UPDATE: %d -> %d (offset = %d)",
(dmg->range.start - c->term.grid->offset) % c->term.grid->size,
(dmg->range.start - c->term.grid->offset) % c->term.grid->size + dmg->range.length,
c->term.grid->offset);
int start = dmg->range.start;
int length = dmg->range.length;
if (start < c->term.grid->offset) {
int end = start + length;
if (end >= c->term.grid->offset) {
start = c->term.grid->offset;
length = end - start;
} else
return;
}
const int cols = c->term.cols;
struct glyph_sequence gseq = {.g = gseq.glyphs};
for (int linear_cursor = start,
row = ((start - c->term.grid->offset) % c->term.grid->size) / cols,
col = ((start - c->term.grid->offset) % c->term.grid->size) % cols;
linear_cursor < start + length;
linear_cursor++,
col = col + 1 >= c->term.cols ? 0 : col + 1,
row += col == 0 ? 1 : 0)
{
assert(row >= 0);
assert(row < c->term.rows);
assert(col >= 0);
assert(col < c->term.cols);
int cell_idx = linear_cursor % c->term.grid->size;
if (cell_idx < 0)
cell_idx += c->term.grid->size;
assert(cell_idx >= 0);
assert(cell_idx < c->term.rows * c->term.cols);
const struct cell *cell = &c->term.grid->cells[cell_idx];
/* Cursor here? */
bool has_cursor
= (!c->term.hide_cursor &&
(c->term.cursor.linear == linear_cursor - c->term.grid->offset));
int x = col * c->term.cell_width;
int y = row * c->term.cell_height;
int width = c->term.cell_width;
int height = c->term.cell_height;
struct rgba foreground = cell->attrs.have_foreground
? cell->attrs.foreground : c->term.foreground;
struct rgba background = cell->attrs.have_background
? cell->attrs.background : c->term.background;
if (has_cursor) {
struct rgba swap = foreground;
foreground = background;
background = swap;
}
if (cell->attrs.reverse) {
struct rgba swap = foreground;
foreground = background;
background = swap;
}
/* Background */
cairo_set_source_rgba(
buf->cairo, background.r, background.g, background.b, background.a);
cairo_rectangle(buf->cairo, x, y, width, height);
cairo_fill(buf->cairo);
if (cell->c[0] == '\0' || cell->c[0] == ' ')
continue;
if (cell->attrs.conceal)
continue;
/*
* cairo_show_glyphs() apparently works *much* faster when
* called once with a large array of glyphs, compared to
* multiple calls with a single glyph.
*
* So, collect glyphs until cell attributes change, then we
* 'flush' (render) the glyphs.
*/
if (memcmp(&cell->attrs, &gseq.attrs, sizeof(cell->attrs)) != 0 ||
gseq.count >= sizeof(gseq.glyphs) / sizeof(gseq.glyphs[0]) - 10 ||
memcmp(&gseq.foreground, &foreground, sizeof(foreground)) != 0)
{
if (gseq.count >= sizeof(gseq.glyphs) / sizeof(gseq.glyphs[0]) - 10)
LOG_WARN("hit glyph limit");
cairo_set_scaled_font(buf->cairo, attrs_to_font(c, &gseq.attrs));
cairo_set_source_rgba(
buf->cairo, gseq.foreground.r, gseq.foreground.g,
gseq.foreground.b, gseq.foreground.a);
cairo_set_operator(buf->cairo, CAIRO_OPERATOR_OVER);
cairo_show_glyphs(buf->cairo, gseq.glyphs, gseq.count);
gseq.g = gseq.glyphs;
gseq.count = 0;
gseq.attrs = cell->attrs;
gseq.foreground = foreground;
}
int new_glyphs
= sizeof(gseq.glyphs) / sizeof(gseq.glyphs[0]) - gseq.count;
cairo_status_t status = cairo_scaled_font_text_to_glyphs(
attrs_to_font(c, &cell->attrs), x, y + c->fextents.ascent,
cell->c, strlen(cell->c), &gseq.g, &new_glyphs,
NULL, NULL, NULL);
if (status != CAIRO_STATUS_SUCCESS)
continue;
gseq.g += new_glyphs;
gseq.count += new_glyphs;
assert(gseq.count <= sizeof(gseq.glyphs) / sizeof(gseq.glyphs[0]));
}
if (gseq.count > 0) {
cairo_set_scaled_font(buf->cairo, attrs_to_font(c, &gseq.attrs));
cairo_set_source_rgba(
buf->cairo, gseq.foreground.r, gseq.foreground.g,
gseq.foreground.b, gseq.foreground.a);
cairo_set_operator(buf->cairo, CAIRO_OPERATOR_OVER);
cairo_show_glyphs(buf->cairo, gseq.glyphs, gseq.count);
}
wl_surface_damage_buffer(
c->wl.surface,
0, ((dmg->range.start - c->term.grid->offset) / cols) * c->term.cell_height,
buf->width, (dmg->range.length + cols - 1) / cols * c->term.cell_height);
}
static void
grid_render_erase(struct context *c, struct buffer *buf, const struct damage *dmg)
{
LOG_DBG("damage: ERASE: %d -> %d (offset = %d)",
(dmg->range.start - c->term.grid->offset) % c->term.grid->size,
(dmg->range.start - c->term.grid->offset) % c->term.grid->size + dmg->range.length,
c->term.grid->offset);
assert(dmg->range.start >= c->term.grid->offset);
cairo_set_source_rgba(
buf->cairo, default_background.r, default_background.g,
default_background.b, default_background.a);
const int cols = c->term.cols;
int start = (dmg->range.start - c->term.grid->offset) % c->term.grid->size;
int left = dmg->range.length;
int row = start / cols;
int col = start % cols;
/* Partial initial line */
if (col != 0) {
int cell_count = min(left, cols - col);
int x = col * c->term.cell_width;
int y = row * c->term.cell_height;
int width = cell_count * c->term.cell_width;
int height = c->term.cell_height;
cairo_rectangle(buf->cairo, x, y, width, height);
cairo_fill(buf->cairo);
wl_surface_damage_buffer(c->wl.surface, x, y, width, height);
start += cell_count;
left -= cell_count;
row = start / cols;
col = start % cols;
}
assert(left == 0 || col == 0);
/* One or more full lines left */
if (left >= cols) {
int line_count = left / cols;
int x = 0;
int y = row * c->term.cell_height;
int width = buf->width;
int height = line_count * c->term.cell_height;
cairo_rectangle(buf->cairo, x, y, width, height);
cairo_fill(buf->cairo);
wl_surface_damage_buffer(c->wl.surface, x, y, width, height);
start += line_count * cols;
left -= line_count * cols;
row += line_count;
col = 0;
}
assert(left == 0 || col == 0);
assert(left < cols);
/* Partial last line */
if (left > 0) {
int x = 0;
int y = row * c->term.cell_height;
int width = left * c->term.cell_width;
int height = c->term.cell_height;
cairo_rectangle(buf->cairo, x, y, width, height);
cairo_fill(buf->cairo);
wl_surface_damage_buffer(c->wl.surface, x, y, width, height);
}
}
static void
grid_render_scroll(struct context *c, struct buffer *buf,
const struct damage *dmg)
{
int dst_y = (dmg->scroll.region.start + 0) * c->term.cell_height;
int src_y = (dmg->scroll.region.start + dmg->scroll.lines) * c->term.cell_height;
int width = buf->width;
int height = (dmg->scroll.region.end - dmg->scroll.region.start - dmg->scroll.lines) * c->term.cell_height;
const uint32_t stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
LOG_DBG("damage: SCROLL: %d-%d by %d lines (dst-y: %d, src-y: %d, "
"height: %d, stride: %d, mmap-size: %zu)",
dmg->scroll.region.start, dmg->scroll.region.end,
dmg->scroll.lines,
dst_y, src_y, height, stride,
buf->size);
if (height > 0) {
cairo_surface_flush(buf->cairo_surface);
uint8_t *raw = cairo_image_surface_get_data(buf->cairo_surface);
memmove(raw + dst_y * stride, raw + src_y * stride, height * stride);
cairo_surface_mark_dirty(buf->cairo_surface);
wl_surface_damage_buffer(c->wl.surface, 0, dst_y, width, height);
}
const int cols = c->term.cols;
struct damage erase = {
.type = DAMAGE_ERASE,
.range = {
.start = c->term.grid->offset + max(dmg->scroll.region.end - dmg->scroll.lines,
dmg->scroll.region.start) * cols,
.length = min(dmg->scroll.region.end - dmg->scroll.region.start,
dmg->scroll.lines) * cols,
},
};
grid_render_erase(c, buf, &erase);
}
static void
grid_render_scroll_reverse(struct context *c, struct buffer *buf,
const struct damage *dmg)
{
int src_y = (dmg->scroll.region.start + 0) * c->term.cell_height;
int dst_y = (dmg->scroll.region.start + dmg->scroll.lines) * c->term.cell_height;
int width = buf->width;
int height = (dmg->scroll.region.end - dmg->scroll.region.start - dmg->scroll.lines) * c->term.cell_height;
const uint32_t stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
LOG_DBG("damage: SCROLL REVERSE: %d-%d by %d lines (dst-y: %d, src-y: %d, "
"height: %d, stride: %d, mmap-size: %zu)",
dmg->scroll.region.start, dmg->scroll.region.end,
dmg->scroll.lines,
dst_y, src_y, height, stride,
buf->size);
if (height > 0) {
cairo_surface_flush(buf->cairo_surface);
uint8_t *raw = cairo_image_surface_get_data(buf->cairo_surface);
memmove(raw + dst_y * stride, raw + src_y * stride, height * stride);
cairo_surface_mark_dirty(buf->cairo_surface);
wl_surface_damage_buffer(c->wl.surface, 0, dst_y, width, height);
}
const int cols = c->term.cols;
struct damage erase = {
.type = DAMAGE_ERASE,
.range = {
.start = c->term.grid->offset + dmg->scroll.region.start * cols,
.length = min(dmg->scroll.region.end - dmg->scroll.region.start,
dmg->scroll.lines) * cols,
},
};
grid_render_erase(c, buf, &erase);
}
static void
grid_render(struct context *c)
{
static int last_cursor;
if (tll_length(c->term.grid->damage) == 0 &&
tll_length(c->term.grid->scroll_damage) == 0 &&
last_cursor == c->term.grid->offset + c->term.cursor.linear)
{
return;
}
assert(c->width > 0);
assert(c->height > 0);
struct buffer *buf = shm_get_buffer(c->wl.shm, c->width, c->height);
cairo_set_operator(buf->cairo, CAIRO_OPERATOR_SOURCE);
static struct buffer *last_buf = NULL;
if (last_buf != buf) {
if (last_buf != NULL)
LOG_WARN("new buffer");
last_buf = buf;
}
tll_foreach(c->term.grid->scroll_damage, it) {
switch (it->item.type) {
case DAMAGE_SCROLL:
grid_render_scroll(c, buf, &it->item);
break;
case DAMAGE_SCROLL_REVERSE:
grid_render_scroll_reverse(c, buf, &it->item);
break;
case DAMAGE_UPDATE:
case DAMAGE_ERASE:
assert(false);
break;
}
tll_remove(c->term.grid->scroll_damage, it);
}
tll_foreach(c->term.grid->damage, it) {
switch (it->item.type) {
case DAMAGE_ERASE: grid_render_erase(c, buf, &it->item); break;
case DAMAGE_UPDATE: grid_render_update(c, buf, &it->item); break;
case DAMAGE_SCROLL:
case DAMAGE_SCROLL_REVERSE:
assert(false);
break;
}
tll_remove(c->term.grid->damage, it);
}
/* TODO: break out to function */
/* Re-render last cursor cell and current cursor cell */
/* Make sure previous cursor is refreshed (to avoid "ghost" cursors) */
if (last_cursor != c->term.cursor.linear) {
struct damage prev_cursor = {
.type = DAMAGE_UPDATE,
.range = {.start = last_cursor, .length = 1},
};
grid_render_update(c, buf, &prev_cursor);
}
struct damage cursor = {
.type = DAMAGE_UPDATE,
.range = {.start = c->term.grid->offset + c->term.cursor.linear, .length = 1},
};
grid_render_update(c, buf, &cursor);
last_cursor = c->term.grid->offset + c->term.cursor.linear;
c->term.grid->offset %= c->term.grid->size;
if (c->term.grid->offset < 0)
c->term.grid->offset += c->term.grid->size;
//cairo_surface_flush(buf->cairo_surface);
wl_surface_attach(c->wl.surface, buf->wl_buf, 0, 0);
struct wl_callback *cb = wl_surface_frame(c->wl.surface);
wl_callback_add_listener(cb, &frame_listener, c);
c->frame_is_scheduled = true;
wl_surface_commit(c->wl.surface);
}
static void
frame_callback(void *data, struct wl_callback *wl_callback, uint32_t callback_data)
{
struct context *c = data;
c->frame_is_scheduled = false;
wl_callback_destroy(wl_callback);
grid_render(c);
}
static void
resize(struct context *c, int width, int height)
{
if (width == c->width && height == c->height)
return;
c->width = width;
c->height = height;
const size_t old_rows = c->term.rows;
const size_t normal_old_size = c->term.normal.size;
const size_t alt_old_size = c->term.alt.size;
c->term.cols = c->width / c->term.cell_width;
c->term.rows = c->height / c->term.cell_height;
c->term.normal.size = c->term.cols * c->term.rows;
c->term.alt.size = c->term.cols * c->term.rows;
c->term.normal.cells = realloc(
c->term.normal.cells,
c->term.normal.size * sizeof(c->term.normal.cells[0]));
c->term.alt.cells = realloc(
c->term.alt.cells,
c->term.alt.size * sizeof(c->term.alt.cells[0]));
for (size_t i = normal_old_size; i < c->term.normal.size; i++) {
c->term.normal.cells[i] = (struct cell){
.attrs = {.foreground = default_foreground,
.background = default_background},
};
}
for (size_t i = alt_old_size; i < c->term.alt.size; i++) {
c->term.alt.cells[i] = (struct cell){
.attrs = {.foreground = default_foreground,
.background = default_background},
};
}
LOG_INFO("resize: %dx%d, grid: cols=%d, rows=%d",
c->width, c->height, c->term.cols, c->term.rows);
/* Update environment variables */
char cols_s[12], rows_s[12];
sprintf(cols_s, "%d", c->term.cols);
sprintf(rows_s, "%d", c->term.rows);
setenv("COLUMNS", cols_s, 1);
setenv("LINES", rows_s, 1);
/* Signal TIOCSWINSZ */
if (ioctl(c->term.ptmx, TIOCSWINSZ,
&(struct winsize){
.ws_row = c->term.rows,
.ws_col = c->term.cols,
.ws_xpixel = c->width,
.ws_ypixel = c->height}) == -1)
{
LOG_ERRNO("TIOCSWINSZ");
}
if (c->term.scroll_region.end == old_rows)
c->term.scroll_region.end = c->term.rows;
term_cursor_to(
&c->term,
min(c->term.cursor.row, c->term.rows),
min(c->term.cursor.col, c->term.cols));
term_damage_all(&c->term);
if (!c->frame_is_scheduled)
grid_render(c);
}
static void
shm_format(void *data, struct wl_shm *wl_shm, uint32_t format)
{
}
static const struct wl_shm_listener shm_listener = {
.format = &shm_format,
};
static void
xdg_wm_base_ping(void *data, struct xdg_wm_base *shell, uint32_t serial)
{
LOG_DBG("wm base ping");
xdg_wm_base_pong(shell, serial);
}
static const struct xdg_wm_base_listener xdg_wm_base_listener = {
.ping = &xdg_wm_base_ping,
};
static void
seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
enum wl_seat_capability caps)
{
struct context *c = data;
if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD))
return;
if (c->wl.keyboard != NULL)
wl_keyboard_release(c->wl.keyboard);
c->wl.keyboard = wl_seat_get_keyboard(wl_seat);
wl_keyboard_add_listener(c->wl.keyboard, &keyboard_listener, &c->term);
}
static void
seat_handle_name(void *data, struct wl_seat *wl_seat, const char *name)
{
}
static const struct wl_seat_listener seat_listener = {
.capabilities = seat_handle_capabilities,
.name = seat_handle_name,
};
static void
handle_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version)
{
//LOG_DBG("global: %s", interface);
struct context *c = data;
if (strcmp(interface, wl_compositor_interface.name) == 0) {
c->wl.compositor = wl_registry_bind(
c->wl.registry, name, &wl_compositor_interface, 4);
}
else if (strcmp(interface, wl_shm_interface.name) == 0) {
c->wl.shm = wl_registry_bind(c->wl.registry, name, &wl_shm_interface, 1);
wl_shm_add_listener(c->wl.shm, &shm_listener, &c->wl);
wl_display_roundtrip(c->wl.display);
}
else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
c->wl.shell = wl_registry_bind(
c->wl.registry, name, &xdg_wm_base_interface, 1);
xdg_wm_base_add_listener(c->wl.shell, &xdg_wm_base_listener, c);
}
else if (strcmp(interface, wl_seat_interface.name) == 0) {
c->wl.seat = wl_registry_bind(c->wl.registry, name, &wl_seat_interface, 4);
wl_seat_add_listener(c->wl.seat, &seat_listener, c);
wl_display_roundtrip(c->wl.display);
}
#if 0
else if (strcmp(interface, wl_output_interface.name) == 0) {
struct wl_output *output = wl_registry_bind(
c->wl.registry, name, &wl_output_interface, 3);
tll_push_back(c->wl.monitors, ((struct monitor){.output = output}));
struct monitor *mon = &tll_back(c->wl.monitors);
wl_output_add_listener(output, &output_listener, mon);
/*
* The "output" interface doesn't give us the monitors'
* identifiers (e.g. "LVDS-1"). Use the XDG output interface
* for that.
*/
assert(c->wl.xdg_output_manager != NULL);
mon->xdg = zxdg_output_manager_v1_get_xdg_output(
c->wl.xdg_output_manager, mon->output);
zxdg_output_v1_add_listener(mon->xdg, &xdg_output_listener, mon);
wl_display_roundtrip(c->wl.display);
}
#endif
#if 0
else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
c->wl.layer_shell = wl_registry_bind(
c->wl.registry, name, &zwlr_layer_shell_v1_interface, 1);
}
#endif
#if 0
else if (strcmp(interface, wl_seat_interface.name) == 0) {
c->wl.seat = wl_registry_bind(c->wl.registry, name, &wl_seat_interface, 4);
wl_seat_add_listener(c->wl.seat, &seat_listener, c);
wl_display_roundtrip(c->wl.display);
}
#endif
#if 0
else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) {
c->wl.xdg_output_manager = wl_registry_bind(
c->wl.registry, name, &zxdg_output_manager_v1_interface, 2);
}
#endif
}
static void
xdg_toplevel_configure(void *data, struct xdg_toplevel *xdg_toplevel,
int32_t width, int32_t height, struct wl_array *states)
{
//struct context *c = data;
//LOG_DBG("xdg-toplevel: configure: %dx%d", width, height);
if (width <= 0 || height <= 0)
return;
resize(data, width, height);
}
static void
xdg_toplevel_close(void *data, struct xdg_toplevel *xdg_toplevel)
{
struct context *c = data;
LOG_DBG("xdg-toplevel: close");
c->quit = true;
wl_display_roundtrip(c->wl.display);
}
static const struct xdg_toplevel_listener xdg_toplevel_listener = {
.configure = &xdg_toplevel_configure,
.close = &xdg_toplevel_close,
};
static void
xdg_surface_configure(void *data, struct xdg_surface *xdg_surface,
uint32_t serial)
{
//LOG_DBG("xdg-surface: configure");
xdg_surface_ack_configure(xdg_surface, serial);
}
static const struct xdg_surface_listener xdg_surface_listener = {
.configure = &xdg_surface_configure,
};
static void
handle_global_remove(void *data, struct wl_registry *registry, uint32_t name)
{
LOG_WARN("global removed: %u", name);
assert(false);
}
static const struct wl_registry_listener registry_listener = {
.global = &handle_global,
.global_remove = &handle_global_remove,
};
static int
keyboard_repeater(void *arg)
{
struct terminal *term = arg;
while (true) {
LOG_DBG("repeater: waiting for start");
mtx_lock(&term->kbd.repeat.mutex);
while (term->kbd.repeat.cmd == REPEAT_STOP)
cnd_wait(&term->kbd.repeat.cond, &term->kbd.repeat.mutex);
if (term->kbd.repeat.cmd == REPEAT_EXIT) {
mtx_unlock(&term->kbd.repeat.mutex);
return 0;
}
restart:
LOG_DBG("repeater: started");
assert(term->kbd.repeat.cmd == REPEAT_START);
const long rate_delay = 1000000000 / term->kbd.repeat.rate;
long delay = term->kbd.repeat.delay * 1000000;
while (true) {
assert(term->kbd.repeat.rate > 0);
struct timespec timeout;
clock_gettime(CLOCK_REALTIME, &timeout);
timeout.tv_nsec += delay;
if (timeout.tv_nsec >= 1000000000) {
timeout.tv_sec += timeout.tv_nsec / 1000000000;
timeout.tv_nsec %= 1000000000;
}
int ret = cnd_timedwait(&term->kbd.repeat.cond, &term->kbd.repeat.mutex, &timeout);
if (ret == thrd_success) {
if (term->kbd.repeat.cmd == REPEAT_START)
goto restart;
else if (term->kbd.repeat.cmd == REPEAT_STOP) {
mtx_unlock(&term->kbd.repeat.mutex);
break;
} else if (term->kbd.repeat.cmd == REPEAT_EXIT) {
mtx_unlock(&term->kbd.repeat.mutex);
return 0;
}
}
assert(ret == thrd_timedout);
assert(term->kbd.repeat.cmd == REPEAT_START);
LOG_DBG("repeater: repeat: %u", term->kbd.repeat.key);
if (write(term->kbd.repeat.pipe_write_fd, &term->kbd.repeat.key,
sizeof(term->kbd.repeat.key)) != sizeof(term->kbd.repeat.key))
{
LOG_ERRNO("faile to write repeat key to repeat pipe");
mtx_unlock(&term->kbd.repeat.mutex);
return 0;
}
delay = rate_delay;
}
}
assert(false);
return 1;
}
int
main(int argc, char *const *argv)
{
int ret = EXIT_FAILURE;
static const struct option longopts[] = {
{"font", required_argument, 0, 'f'},
{NULL, no_argument, 0, 0},
};
const char *font_name = "Dina:pixelsize=12";
while (true) {
int c = getopt_long(argc, argv, ":f:h", longopts, NULL);
if (c == -1)
break;
switch (c) {
case 'f':
font_name = optarg;
break;
case 'h':
break;
case ':':
fprintf(stderr, "error: -%c: missing required argument\n", optopt);
return EXIT_FAILURE;
case '?':
fprintf(stderr, "error: -%c: invalid option\n", optopt);
return EXIT_FAILURE;
}
}
setlocale(LC_ALL, "");
int repeat_pipe_fds[2] = {-1, -1};
if (pipe2(repeat_pipe_fds, O_CLOEXEC) == -1) {
LOG_ERRNO("failed to create pipe for repeater thread");
return ret;
}
struct context c = {
.quit = false,
.term = {
.ptmx = posix_openpt(O_RDWR | O_NOCTTY),
.decckm = DECCKM_CSI,
.keypad_mode = KEYPAD_NUMERICAL, /* TODO: verify */
.vt = {
.state = 1, /* STATE_GROUND */
},
.kbd = {
.repeat = {
.pipe_read_fd = repeat_pipe_fds[0],
.pipe_write_fd = repeat_pipe_fds[1],
.cmd = REPEAT_STOP,
},
},
.foreground = default_foreground,
.background = default_background,
.normal = {.damage = tll_init(), .scroll_damage = tll_init()},
.alt = {.damage = tll_init(), .scroll_damage = tll_init()},
.grid = &c.term.normal,
},
};
mtx_init(&c.term.kbd.repeat.mutex, mtx_plain);
cnd_init(&c.term.kbd.repeat.cond);
thrd_t keyboard_repeater_id;
thrd_create(&keyboard_repeater_id, &keyboard_repeater, &c.term);
c.fonts[0] = font_from_name(font_name);
if (c.fonts[0] == NULL)
goto out;
{
char fname[1024];
snprintf(fname, sizeof(fname), "%s:style=bold", font_name);
c.fonts[1] = font_from_name(fname);
snprintf(fname, sizeof(fname), "%s:style=italic", font_name);
c.fonts[2] = font_from_name(fname);
snprintf(fname, sizeof(fname), "%s:style=bold italic", font_name);
c.fonts[3] = font_from_name(fname);
}
cairo_scaled_font_extents(c.fonts[0], &c.fextents);
c.term.cell_width = (int)ceil(c.fextents.max_x_advance);
c.term.cell_height = (int)ceil(c.fextents.height);
LOG_DBG("font: height: %.2f, x-advance: %.2f",
c.fextents.height, c.fextents.max_x_advance);
assert(c.fextents.max_y_advance == 0);
if (c.term.ptmx == -1) {
LOG_ERRNO("failed to open pseudo terminal");
goto out;
}
c.wl.display = wl_display_connect(NULL);
if (c.wl.display == NULL) {
LOG_ERR("failed to connect to wayland; no compositor running?");
goto out;
}
c.wl.registry = wl_display_get_registry(c.wl.display);
if (c.wl.registry == NULL) {
LOG_ERR("failed to get wayland registry");
goto out;
}
wl_registry_add_listener(c.wl.registry, &registry_listener, &c);
wl_display_roundtrip(c.wl.display);
if (c.wl.compositor == NULL) {
LOG_ERR("no compositor");
goto out;
}
if (c.wl.shm == NULL) {
LOG_ERR("no shared memory buffers interface");
goto out;
}
if (c.wl.shell == NULL) {
LOG_ERR("no XDG shell interface");
goto out;
}
c.wl.surface = wl_compositor_create_surface(c.wl.compositor);
if (c.wl.surface == NULL) {
LOG_ERR("failed to create wayland surface");
goto out;
}
c.wl.xdg_surface = xdg_wm_base_get_xdg_surface(c.wl.shell, c.wl.surface);
xdg_surface_add_listener(c.wl.xdg_surface, &xdg_surface_listener, &c);
c.wl.xdg_toplevel = xdg_surface_get_toplevel(c.wl.xdg_surface);
xdg_toplevel_add_listener(c.wl.xdg_toplevel, &xdg_toplevel_listener, &c);
xdg_toplevel_set_app_id(c.wl.xdg_toplevel, "f00ter");
xdg_toplevel_set_title(c.wl.xdg_toplevel, "f00ter");
wl_surface_commit(c.wl.surface);
wl_display_roundtrip(c.wl.display);
/* TODO: use font metrics to calculate initial size from ROWS x COLS */
const int default_width = 300;
const int default_height = 300;
resize(&c, default_width, default_height);
wl_display_dispatch_pending(c.wl.display);
c.term.slave = fork();
switch (c.term.slave) {
case -1:
LOG_ERRNO("failed to fork");
goto out;
case 0:
/* Child */
slave_spawn(c.term.ptmx);
assert(false);
break;
default:
LOG_DBG("slave has PID %d", c.term.slave);
break;
}
/* Read logic requires non-blocking mode */
{
int fd_flags = fcntl(c.term.ptmx, F_GETFL);
if (fd_flags == -1) {
LOG_ERRNO("failed to set non blocking mode on PTY master");
goto out;
}
if (fcntl(c.term.ptmx, F_SETFL, fd_flags | O_NONBLOCK) == -1) {
LOG_ERRNO("failed to set non blocking mode on PTY master");
goto out;
}
}
while (true) {
struct pollfd fds[] = {
{.fd = wl_display_get_fd(c.wl.display), .events = POLLIN},
{.fd = c.term.ptmx, .events = POLLIN},
{.fd = c.term.kbd.repeat.pipe_read_fd, .events = POLLIN},
};
wl_display_flush(c.wl.display);
poll(fds, sizeof(fds) / sizeof(fds[0]), -1);
if (fds[0].revents & POLLIN) {
wl_display_dispatch(c.wl.display);
if (c.quit) {
ret = EXIT_SUCCESS;
break;
}
}
if (fds[0].revents & POLLHUP) {
LOG_WARN("disconnected from wayland");
break;
}
if (fds[1].revents & POLLIN) {
for (size_t i = 0; i < 3; i++) {
uint8_t data[8192];
ssize_t count = read(c.term.ptmx, data, sizeof(data));
if (count < 0) {
if (errno != EAGAIN)
LOG_ERRNO("failed to read from pseudo terminal");
break;
}
vt_from_slave(&c.term, data, count);
}
if (!c.frame_is_scheduled)
grid_render(&c);
}
if (fds[1].revents & POLLHUP) {
ret = EXIT_SUCCESS;
break;
}
if (fds[2].revents & POLLIN) {
uint32_t key;
if (read(c.term.kbd.repeat.pipe_read_fd, &key, sizeof(key)) != sizeof(key)) {
LOG_ERRNO("failed to read repeat key from repeat pipe");
break;
}
c.term.kbd.repeat.dont_re_repeat = true;
input_repeat(&c.term, key);
c.term.kbd.repeat.dont_re_repeat = false;
}
if (fds[2].revents & POLLHUP)
LOG_ERR("keyboard repeat handling thread died");
}
out:
mtx_lock(&c.term.kbd.repeat.mutex);
c.term.kbd.repeat.cmd = REPEAT_EXIT;
cnd_signal(&c.term.kbd.repeat.cond);
mtx_unlock(&c.term.kbd.repeat.mutex);
shm_fini();
if (c.wl.xdg_toplevel != NULL)
xdg_toplevel_destroy(c.wl.xdg_toplevel);
if (c.wl.xdg_surface != NULL)
xdg_surface_destroy(c.wl.xdg_surface);
if (c.wl.surface != NULL)
wl_surface_destroy(c.wl.surface);
if (c.wl.shell != NULL)
xdg_wm_base_destroy(c.wl.shell);
if (c.wl.shm != NULL)
wl_shm_destroy(c.wl.shm);
if (c.wl.compositor != NULL)
wl_compositor_destroy(c.wl.compositor);
if (c.wl.registry != NULL)
wl_registry_destroy(c.wl.registry);
if (c.wl.display != NULL)
wl_display_disconnect(c.wl.display);
free(c.term.normal.cells);
free(c.term.alt.cells);
for (size_t i = 0; i < sizeof(c.fonts) / sizeof(c.fonts[0]); i++) {
if (c.fonts[i] != NULL)
cairo_scaled_font_destroy(c.fonts[i]);
}
if (c.term.ptmx != -1)
close(c.term.ptmx);
thrd_join(keyboard_repeater_id, NULL);
cnd_destroy(&c.term.kbd.repeat.cond);
mtx_destroy(&c.term.kbd.repeat.mutex);
close(c.term.kbd.repeat.pipe_read_fd);
close(c.term.kbd.repeat.pipe_write_fd);
cairo_debug_reset_static_data();
return ret;
}
Reference in a new issue View git blame Copy permalink