mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-05 04:06:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/commands.c

113 lines
3.1 KiB
C
Raw Normal View History

wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
#include "commands.h"
#define LOG_MODULE "commands"
#define LOG_ENABLE_DBG 1
#include "log.h"
#include "terminal.h"
#include "render.h"
#include "grid.h"
#define max(x, y) ((x) > (y) ? (x) : (y))
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
#define min(x, y) ((x) < (y) ? (x) : (y))
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
void
scrollback: initial support for mouse scrolling
2019-07-10 09:15:37 +02:00
cmd_scrollback_up(struct terminal *term, int rows)
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
{
scrollback: initial support for mouse scrolling
2019-07-10 09:15:37 +02:00
if (term->grid == &term->alt)
return;
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
rows = min(rows, term->grid->num_rows - term->rows);
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
assert(term->grid->offset >= 0);
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
assert(rows <= term->rows);
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
int new_view = (term->grid->view + term->grid->num_rows - rows) % term->grid->num_rows;
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
assert(new_view >= 0);
assert(new_view < term->grid->num_rows);
scrollback: initial support for mouse scrolling
2019-07-10 09:15:37 +02:00
/* Avoid scrolling in uninitialized rows */
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
while (!term->grid->rows[new_view]->initialized)
new_view = (new_view + 1) % term->grid->num_rows;
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
/* Don't scroll past scrollback history */
scrollback: fix off-by-one when grid size matches terminal/window size
2019-07-10 09:55:53 +02:00
int end = (term->grid->offset + term->rows - 1) % term->grid->num_rows;
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
if (end >= term->grid->offset) {
/* Not wrapped */
scrollback: fix off-by-one when grid size matches terminal/window size
2019-07-10 09:55:53 +02:00
if (new_view >= term->grid->offset && new_view <= end)
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
new_view = end;
} else {
scrollback: fix off-by-one when grid size matches terminal/window size
2019-07-10 09:55:53 +02:00
if (new_view >= term->grid->offset || new_view <= end)
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
new_view = end;
}
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
LOG_DBG("scrollback UP: %d -> %d (offset = %d, rows = %d)",
term->grid->view, new_view, term->grid->offset, term->grid->num_rows);
scrollback: don't redraw if view doesn't change
2019-07-10 09:30:35 +02:00
if (new_view == term->grid->view)
return;
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
term->grid->view = new_view;
for (int i = 0; i < term->rows; i++)
grid_row_in_view(term->grid, i)->dirty = true;
if (term->frame_callback == NULL)
grid_render(term);
}
void
scrollback: initial support for mouse scrolling
2019-07-10 09:15:37 +02:00
cmd_scrollback_down(struct terminal *term, int rows)
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
{
scrollback: initial support for mouse scrolling
2019-07-10 09:15:37 +02:00
if (term->grid == &term->alt)
return;
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
rows = min(rows, term->grid->num_rows - term->rows);
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
assert(term->grid->offset >= 0);
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
int new_view = (term->grid->view + rows) % term->grid->num_rows;
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
assert(new_view >= 0);
assert(new_view < term->grid->num_rows);
scrollback: initial support for mouse scrolling
2019-07-10 09:15:37 +02:00
/* Prevent scrolling in uninitialized rows */
bool all_initialized = false;
do {
all_initialized = true;
for (int i = 0; i < term->rows; i++) {
int row_no = (new_view + i) % term->grid->num_rows;
if (!term->grid->rows[row_no]->initialized) {
all_initialized = false;
new_view--;
break;
}
}
} while (!all_initialized);
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
/* Don't scroll past scrollback history */
scrollback: fix off-by-one when grid size matches terminal/window size
2019-07-10 09:55:53 +02:00
int end = (term->grid->offset + term->rows - 1) % term->grid->num_rows;
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
if (end >= term->grid->offset) {
/* Not wrapped */
scrollback: fix off-by-one when grid size matches terminal/window size
2019-07-10 09:55:53 +02:00
if (new_view >= term->grid->offset && new_view <= end)
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
new_view = term->grid->offset;
} else {
scrollback: fix off-by-one when grid size matches terminal/window size
2019-07-10 09:55:53 +02:00
if (new_view >= term->grid->offset || new_view <= end)
scrollback: don't scroll past scrollback history
2019-07-10 09:29:36 +02:00
new_view = term->grid->offset;
}
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
LOG_DBG("scrollback DOWN: %d -> %d (offset = %d, rows = %d)",
term->grid->view, new_view, term->grid->offset, term->grid->num_rows);
scrollback: don't redraw if view doesn't change
2019-07-10 09:30:35 +02:00
if (new_view == term->grid->view)
return;
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
term->grid->view = new_view;
for (int i = 0; i < term->rows; i++)
grid_row_in_view(term->grid, i)->dirty = true;
if (term->frame_callback == NULL)
grid_render(term);
}
Reference in a new issue Copy permalink