aboutsummaryrefslogtreecommitdiff
path: root/render.c
diff options
context:
space:
mode:
authorDaniel Eklöf <daniel@ekloef.se>2022-10-10 15:19:43 +0000
committerDaniel Eklöf <daniel@ekloef.se>2022-10-10 15:19:43 +0000
commit3949e3427169f20f050d5df8ae824fa5a8d75fd6 (patch)
tree7830b31070c56144007bed74d8014aa6cf6bde7e /render.c
parentpgo: run xtgettcap without any arguments (diff)
parentrender: rename term->render.resizing -> term->interactive_resizing (diff)
Merge branch 'delayed-reflow'
Diffstat (limited to 'render.c')
-rw-r--r--render.c170
1 files changed, 156 insertions, 14 deletions
diff --git a/render.c b/render.c
index f14911d4..d50606cb 100644
--- a/render.c
+++ b/render.c
@@ -3663,13 +3663,64 @@ tiocswinsz(struct terminal *term)
}
}
+static void
+delayed_reflow_of_normal_grid(struct terminal *term)
+{
+ if (term->interactive_resizing.grid == NULL)
+ return;
+
+ xassert(term->interactive_resizing.new_rows > 0);
+
+ struct coord *const tracking_points[] = {
+ &term->selection.coords.start,
+ &term->selection.coords.end,
+ };
+
+ /* Reflow the original (since before the resize was started) grid,
+ * to the *current* dimensions */
+ grid_resize_and_reflow(
+ term->interactive_resizing.grid,
+ term->interactive_resizing.new_rows, term->normal.num_cols,
+ term->interactive_resizing.old_screen_rows, term->rows,
+ term->selection.coords.end.row >= 0 ? ALEN(tracking_points) : 0,
+ tracking_points);
+
+ /* Replace the current, truncated, “normal” grid with the
+ * correctly reflowed one */
+ grid_free(&term->normal);
+ term->normal = *term->interactive_resizing.grid;
+ free(term->interactive_resizing.grid);
+
+ /* Reset */
+ term->interactive_resizing.grid = NULL;
+ term->interactive_resizing.old_screen_rows = 0;
+ term->interactive_resizing.new_rows = 0;
+
+ /* Invalidate render pointers */
+ shm_unref(term->render.last_buf);
+ term->render.last_buf = NULL;
+ term->render.last_cursor.row = NULL;
+
+ tll_free(term->normal.scroll_damage);
+ sixel_reflow_grid(term, &term->normal);
+
+ if (term->grid == &term->normal) {
+ term_damage_view(term);
+ render_refresh(term);
+ }
+
+ term_ptmx_resume(term);
+}
+
static bool
fdm_tiocswinsz(struct fdm *fdm, int fd, int events, void *data)
{
struct terminal *term = data;
- if (events & EPOLLIN)
+ if (events & EPOLLIN) {
tiocswinsz(term);
+ delayed_reflow_of_normal_grid(term);
+ }
if (term->window->resize_timeout_fd >= 0) {
fdm_del(fdm, term->window->resize_timeout_fd);
@@ -3686,6 +3737,7 @@ send_dimensions_to_client(struct terminal *term)
if (!win->is_resizing || term->conf->resize_delay_ms == 0) {
/* Send new dimensions to client immediately */
tiocswinsz(term);
+ delayed_reflow_of_normal_grid(term);
/* And make sure to reset and deallocate a lingering timer */
if (win->resize_timeout_fd >= 0) {
@@ -3730,8 +3782,10 @@ send_dimensions_to_client(struct terminal *term)
successfully_scheduled = true;
}
- if (!successfully_scheduled)
+ if (!successfully_scheduled) {
tiocswinsz(term);
+ delayed_reflow_of_normal_grid(term);
+ }
}
}
@@ -3846,9 +3900,65 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
const uint32_t scrollback_lines = term->render.scrollback_lines;
+ /*
+ * Since text reflow is slow, don’t do it *while* resizing. Only
+ * do it when done, or after “pausing” the resize for sufficiently
+ * long. We re-use the TIOCSWINSZ timer to handle this. See
+ * send_dimensions_to_client() and fdm_tiocswinsz().
+ *
+ * To be able to do the final reflow correctly, we need a copy of
+ * the original grid, before the resize started.
+ */
+ if (term->window->is_resizing && term->interactive_resizing.grid == NULL) {
+ term_ptmx_pause(term);
+
+ /* Stash the current ‘normal’ grid, as-is, to be used when
+ * doing the final reflow */
+ term->interactive_resizing.old_screen_rows = term->rows;
+ term->interactive_resizing.grid = xmalloc(sizeof(*term->interactive_resizing.grid));
+ *term->interactive_resizing.grid = term->normal;
+
+ /*
+ * Copy the current viewport to a new grid that will be used
+ * during the resize. For now, throw away sixels and OSC-8
+ * URLs. They’ll be "restored" when we do the final reflow.
+ *
+ * We use the ‘alt’ screen’s row count, since we don’t want to
+ * instantiate an unnecessarily large grid.
+ *
+ * TODO:
+ * - sixels?
+ * - OSC-8?
+ */
+ xassert(1 << (32 - __builtin_clz(term->rows)) == term->alt.num_rows);
+ struct grid g = {
+ .num_rows = term->alt.num_rows,
+ .num_cols = term->cols,
+ .offset = 0,
+ .view = 0,
+ .cursor = term->normal.cursor,
+ .saved_cursor = term->normal.saved_cursor,
+ .rows = xcalloc(g.num_rows, sizeof(g.rows[0])),
+ .cur_row = NULL,
+ .scroll_damage = tll_init(),
+ .sixel_images = tll_init(),
+ .kitty_kbd = term->normal.kitty_kbd,
+ };
+
+ for (size_t i = 0, j = term->normal.view; i < term->rows;
+ i++, j = (j + 1) & (term->normal.num_rows - 1))
+ {
+ g.rows[i] = grid_row_alloc(term->cols, false);
+ memcpy(g.rows[i]->cells, term->normal.rows[j]->cells,
+ term->cols * sizeof(g.rows[i]->cells[0]));
+ }
+
+ term->normal = g;
+ }
+
/* Screen rows/cols before resize */
- const int old_cols = term->cols;
- const int old_rows = term->rows;
+ int old_cols = term->cols;
+ int old_rows = term->rows;
/* Screen rows/cols after resize */
const int new_cols = (term->width - 2 * pad_x) / term->cell_width;
@@ -3882,8 +3992,11 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
xassert(term->margins.top >= pad_y);
xassert(term->margins.bottom >= pad_y);
- if (new_cols == old_cols && new_rows == old_rows) {
+ if (new_cols == old_cols && new_rows == old_rows &&
+ (term->interactive_resizing.grid == NULL || term->window->is_resizing))
+ {
LOG_DBG("grid layout unaffected; skipping reflow");
+ term->interactive_resizing.new_rows = new_normal_grid_rows;
goto damage_view;
}
@@ -3906,16 +4019,45 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
* selection’s pivot point coordinates *must* be added to the
* tracking points list.
*/
- struct coord *const tracking_points[] = {
- &term->selection.coords.start,
- &term->selection.coords.end,
- };
-
/* Resize grids */
- grid_resize_and_reflow(
- &term->normal, new_normal_grid_rows, new_cols, old_rows, new_rows,
- term->selection.coords.end.row >= 0 ? ALEN(tracking_points) : 0,
- tracking_points);
+ if (term->window->is_resizing) {
+ /* Simple truncating resize, *while* an interactive resize is
+ * ongoing. */
+ xassert(term->interactive_resizing.grid != NULL);
+ xassert(new_normal_grid_rows > 0);
+ term->interactive_resizing.new_rows = new_normal_grid_rows;
+
+ grid_resize_without_reflow(
+ &term->normal, new_alt_grid_rows, new_cols, old_rows, new_rows);
+ } else {
+ /* Full text reflow */
+
+ if (term->interactive_resizing.grid != NULL) {
+ /* Throw away the current, truncated, “normal” grid, and
+ * use the original grid instead (from before the resize
+ * started) */
+ grid_free(&term->normal);
+ term->normal = *term->interactive_resizing.grid;
+ free(term->interactive_resizing.grid);
+
+ old_rows = term->interactive_resizing.old_screen_rows;
+
+ term->interactive_resizing.grid = NULL;
+ term->interactive_resizing.old_screen_rows = 0;
+ term->interactive_resizing.new_rows = 0;
+ term_ptmx_resume(term);
+ }
+
+ struct coord *const tracking_points[] = {
+ &term->selection.coords.start,
+ &term->selection.coords.end,
+ };
+
+ grid_resize_and_reflow(
+ &term->normal, new_normal_grid_rows, new_cols, old_rows, new_rows,
+ term->selection.coords.end.row >= 0 ? ALEN(tracking_points) : 0,
+ tracking_points);
+ }
grid_resize_without_reflow(
&term->alt, new_alt_grid_rows, new_cols, old_rows, new_rows);