Adding reflow patch (#120)
This commit is contained in:
Stein Gunnar Bakkeby
GitHub
parent
9a41526bfb
commit
3b87b07404
21 changed files with 2347 additions and 82 deletions
931
patch/reflow.c
Normal file
931
patch/reflow.c
Normal file
|
|
@ -0,0 +1,931 @@
|
|||
void
|
||||
tloaddefscreen(int clear, int loadcursor)
|
||||
{
|
||||
int col, row, alt = IS_SET(MODE_ALTSCREEN);
|
||||
|
||||
if (alt) {
|
||||
if (clear) {
|
||||
tclearregion(0, 0, term.col-1, term.row-1, 1);
|
||||
#if SIXEL_PATCH
|
||||
tdeleteimages();
|
||||
#endif // SIXEL_PATCH
|
||||
}
|
||||
col = term.col, row = term.row;
|
||||
tswapscreen();
|
||||
}
|
||||
if (loadcursor)
|
||||
tcursor(CURSOR_LOAD);
|
||||
if (alt)
|
||||
tresizedef(col, row);
|
||||
}
|
||||
|
||||
void
|
||||
tloadaltscreen(int clear, int savecursor)
|
||||
{
|
||||
int col, row, def = !IS_SET(MODE_ALTSCREEN);
|
||||
|
||||
if (savecursor)
|
||||
tcursor(CURSOR_SAVE);
|
||||
if (def) {
|
||||
col = term.col, row = term.row;
|
||||
kscrolldown(&((Arg){ .i = term.scr }));
|
||||
tswapscreen();
|
||||
tresizealt(col, row);
|
||||
}
|
||||
if (clear) {
|
||||
tclearregion(0, 0, term.col-1, term.row-1, 1);
|
||||
#if SIXEL_PATCH
|
||||
tdeleteimages();
|
||||
#endif // SIXEL_PATCH
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
selmove(int n)
|
||||
{
|
||||
sel.ob.y += n, sel.nb.y += n;
|
||||
sel.oe.y += n, sel.ne.y += n;
|
||||
}
|
||||
|
||||
void
|
||||
tclearglyph(Glyph *gp, int usecurattr)
|
||||
{
|
||||
if (usecurattr) {
|
||||
gp->fg = term.c.attr.fg;
|
||||
gp->bg = term.c.attr.bg;
|
||||
} else {
|
||||
gp->fg = defaultfg;
|
||||
gp->bg = defaultbg;
|
||||
}
|
||||
gp->mode = ATTR_NULL;
|
||||
gp->u = ' ';
|
||||
}
|
||||
|
||||
#if SIXEL_PATCH
|
||||
void
|
||||
treflow_moveimages(int oldy, int newy)
|
||||
{
|
||||
ImageList *im;
|
||||
|
||||
for (im = term.images; im; im = im->next) {
|
||||
if (im->y == oldy)
|
||||
im->reflow_y = newy;
|
||||
}
|
||||
}
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
void
|
||||
treflow(int col, int row)
|
||||
{
|
||||
int i, j, x, x2;
|
||||
int oce, nce, bot, scr;
|
||||
int ox = 0, oy = -term.histf, nx = 0, ny = -1, len;
|
||||
int cy = -1; /* proxy for new y coordinate of cursor */
|
||||
int buflen, nlines, del;
|
||||
Line *buf, bufline, line;
|
||||
#if SIXEL_PATCH
|
||||
ImageList *im, *next;
|
||||
|
||||
for (im = term.images; im; im = im->next)
|
||||
im->reflow_y = INT_MIN; /* unset reflow_y */
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
/* y coordinate of cursor line end */
|
||||
for (oce = term.c.y; oce < term.row - 1 &&
|
||||
tiswrapped(term.line[oce]); oce++);
|
||||
|
||||
nlines = HISTSIZE + row;
|
||||
buf = xmalloc(nlines * sizeof(Line));
|
||||
do {
|
||||
if (!nx && ++ny < nlines)
|
||||
buf[ny] = xmalloc(col * sizeof(Glyph));
|
||||
if (!ox) {
|
||||
line = TLINEABS(oy);
|
||||
len = tlinelen(line);
|
||||
}
|
||||
if (oy == term.c.y) {
|
||||
if (!ox)
|
||||
len = MAX(len, term.c.x + 1);
|
||||
/* update cursor */
|
||||
if (cy < 0 && term.c.x - ox < col - nx) {
|
||||
term.c.x = nx + term.c.x - ox, cy = ny;
|
||||
UPDATEWRAPNEXT(0, col);
|
||||
}
|
||||
}
|
||||
/* get reflowed lines in buf */
|
||||
bufline = buf[ny % nlines];
|
||||
if (col - nx > len - ox) {
|
||||
memcpy(&bufline[nx], &line[ox], (len-ox) * sizeof(Glyph));
|
||||
nx += len - ox;
|
||||
if (len == 0 || !(line[len - 1].mode & ATTR_WRAP)) {
|
||||
for (j = nx; j < col; j++)
|
||||
tclearglyph(&bufline[j], 0);
|
||||
#if SIXEL_PATCH
|
||||
treflow_moveimages(oy+term.scr, ny);
|
||||
#endif // SIXEL_PATCH
|
||||
nx = 0;
|
||||
} else if (nx > 0) {
|
||||
bufline[nx - 1].mode &= ~ATTR_WRAP;
|
||||
}
|
||||
ox = 0, oy++;
|
||||
} else if (col - nx == len - ox) {
|
||||
memcpy(&bufline[nx], &line[ox], (col-nx) * sizeof(Glyph));
|
||||
#if SIXEL_PATCH
|
||||
treflow_moveimages(oy+term.scr, ny);
|
||||
#endif // SIXEL_PATCH
|
||||
ox = 0, oy++, nx = 0;
|
||||
} else/* if (col - nx < len - ox) */ {
|
||||
memcpy(&bufline[nx], &line[ox], (col-nx) * sizeof(Glyph));
|
||||
if (bufline[col - 1].mode & ATTR_WIDE) {
|
||||
bufline[col - 2].mode |= ATTR_WRAP;
|
||||
tclearglyph(&bufline[col - 1], 0);
|
||||
ox--;
|
||||
} else {
|
||||
bufline[col - 1].mode |= ATTR_WRAP;
|
||||
}
|
||||
#if SIXEL_PATCH
|
||||
treflow_moveimages(oy+term.scr, ny);
|
||||
#endif // SIXEL_PATCH
|
||||
ox += col - nx;
|
||||
nx = 0;
|
||||
}
|
||||
} while (oy <= oce);
|
||||
if (nx)
|
||||
for (j = nx; j < col; j++)
|
||||
tclearglyph(&bufline[j], 0);
|
||||
|
||||
/* free extra lines */
|
||||
for (i = row; i < term.row; i++)
|
||||
free(term.line[i]);
|
||||
/* resize to new height */
|
||||
term.line = xrealloc(term.line, row * sizeof(Line));
|
||||
|
||||
buflen = MIN(ny + 1, nlines);
|
||||
bot = MIN(ny, row - 1);
|
||||
scr = MAX(row - term.row, 0);
|
||||
/* update y coordinate of cursor line end */
|
||||
nce = MIN(oce + scr, bot);
|
||||
/* update cursor y coordinate */
|
||||
term.c.y = nce - (ny - cy);
|
||||
if (term.c.y < 0) {
|
||||
j = nce, nce = MIN(nce + -term.c.y, bot);
|
||||
term.c.y += nce - j;
|
||||
while (term.c.y < 0) {
|
||||
free(buf[ny-- % nlines]);
|
||||
buflen--;
|
||||
term.c.y++;
|
||||
}
|
||||
}
|
||||
/* allocate new rows */
|
||||
for (i = row - 1; i > nce; i--) {
|
||||
if (i >= term.row)
|
||||
term.line[i] = xmalloc(col * sizeof(Glyph));
|
||||
else
|
||||
term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
|
||||
for (j = 0; j < col; j++)
|
||||
tclearglyph(&term.line[i][j], 0);
|
||||
}
|
||||
/* fill visible area */
|
||||
for (/*i = nce */; i >= term.row; i--, ny--, buflen--)
|
||||
term.line[i] = buf[ny % nlines];
|
||||
for (/*i = term.row - 1 */; i >= 0; i--, ny--, buflen--) {
|
||||
free(term.line[i]);
|
||||
term.line[i] = buf[ny % nlines];
|
||||
}
|
||||
/* fill lines in history buffer and update term.histf */
|
||||
for (/*i = -1 */; buflen > 0 && i >= -HISTSIZE; i--, ny--, buflen--) {
|
||||
j = (term.histi + i + 1 + HISTSIZE) % HISTSIZE;
|
||||
free(term.hist[j]);
|
||||
term.hist[j] = buf[ny % nlines];
|
||||
}
|
||||
term.histf = -i - 1;
|
||||
term.scr = MIN(term.scr, term.histf);
|
||||
/* resize rest of the history lines */
|
||||
for (/*i = -term.histf - 1 */; i >= -HISTSIZE; i--) {
|
||||
j = (term.histi + i + 1 + HISTSIZE) % HISTSIZE;
|
||||
term.hist[j] = xrealloc(term.hist[j], col * sizeof(Glyph));
|
||||
}
|
||||
|
||||
#if SIXEL_PATCH
|
||||
/* move images to the final position */
|
||||
for (im = term.images; im; im = next) {
|
||||
next = im->next;
|
||||
if (im->reflow_y == INT_MIN) {
|
||||
delete_image(im);
|
||||
} else {
|
||||
im->y = im->reflow_y - term.histf + term.scr - (ny + 1);
|
||||
if (im->y - term.scr < -HISTSIZE || im->y - term.scr >= row)
|
||||
delete_image(im);
|
||||
}
|
||||
}
|
||||
|
||||
/* expand images into new text cells or
|
||||
* delete images if there is text behind them */
|
||||
for (im = term.images; im; im = next) {
|
||||
next = im->next;
|
||||
if (im->x < col) {
|
||||
line = TLINE(im->y);
|
||||
x2 = MIN(im->x + im->cols, col);
|
||||
for (del = 0, x = im->x; x < x2; x++) {
|
||||
if ((del = line[x].mode & ATTR_SET))
|
||||
break;
|
||||
line[x].u = ' ';
|
||||
line[x].mode = ATTR_SIXEL;
|
||||
}
|
||||
if (del)
|
||||
delete_image(im);
|
||||
}
|
||||
}
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
for (; buflen > 0; ny--, buflen--)
|
||||
free(buf[ny % nlines]);
|
||||
free(buf);
|
||||
}
|
||||
|
||||
void
|
||||
rscrolldown(int n)
|
||||
{
|
||||
int i;
|
||||
Line temp;
|
||||
|
||||
/* can never be true as of now
|
||||
if (IS_SET(MODE_ALTSCREEN))
|
||||
return; */
|
||||
|
||||
if ((n = MIN(n, term.histf)) <= 0)
|
||||
return;
|
||||
|
||||
for (i = term.c.y + n; i >= n; i--) {
|
||||
temp = term.line[i];
|
||||
term.line[i] = term.line[i-n];
|
||||
term.line[i-n] = temp;
|
||||
}
|
||||
for (/*i = n - 1 */; i >= 0; i--) {
|
||||
temp = term.line[i];
|
||||
term.line[i] = term.hist[term.histi];
|
||||
term.hist[term.histi] = temp;
|
||||
term.histi = (term.histi - 1 + HISTSIZE) % HISTSIZE;
|
||||
}
|
||||
term.c.y += n;
|
||||
term.histf -= n;
|
||||
if ((i = term.scr - n) >= 0) {
|
||||
term.scr = i;
|
||||
} else {
|
||||
#if SIXEL_PATCH
|
||||
scroll_images(n - term.scr);
|
||||
#endif // SIXEL_PATCH
|
||||
term.scr = 0;
|
||||
if (sel.ob.x != -1 && !sel.alt)
|
||||
selmove(-i);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
tresizedef(int col, int row)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
/* return if dimensions haven't changed */
|
||||
if (term.col == col && term.row == row) {
|
||||
tfulldirt();
|
||||
return;
|
||||
}
|
||||
if (col != term.col) {
|
||||
if (!sel.alt)
|
||||
selremove();
|
||||
treflow(col, row);
|
||||
} else {
|
||||
/* slide screen up if otherwise cursor would get out of the screen */
|
||||
if (term.c.y >= row) {
|
||||
tscrollup(0, term.row - 1, term.c.y - row + 1, SCROLL_RESIZE);
|
||||
term.c.y = row - 1;
|
||||
}
|
||||
for (i = row; i < term.row; i++)
|
||||
free(term.line[i]);
|
||||
|
||||
/* resize to new height */
|
||||
term.line = xrealloc(term.line, row * sizeof(Line));
|
||||
/* allocate any new rows */
|
||||
for (i = term.row; i < row; i++) {
|
||||
term.line[i] = xmalloc(col * sizeof(Glyph));
|
||||
for (j = 0; j < col; j++)
|
||||
tclearglyph(&term.line[i][j], 0);
|
||||
}
|
||||
/* scroll down as much as height has increased */
|
||||
rscrolldown(row - term.row);
|
||||
}
|
||||
/* update terminal size */
|
||||
term.col = col, term.row = row;
|
||||
/* reset scrolling region */
|
||||
term.top = 0, term.bot = row - 1;
|
||||
/* dirty all lines */
|
||||
tfulldirt();
|
||||
}
|
||||
|
||||
void
|
||||
tresizealt(int col, int row)
|
||||
{
|
||||
int i, j;
|
||||
#if SIXEL_PATCH
|
||||
ImageList *im, *next;
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
/* return if dimensions haven't changed */
|
||||
if (term.col == col && term.row == row) {
|
||||
tfulldirt();
|
||||
return;
|
||||
}
|
||||
if (sel.alt)
|
||||
selremove();
|
||||
/* slide screen up if otherwise cursor would get out of the screen */
|
||||
for (i = 0; i <= term.c.y - row; i++)
|
||||
free(term.line[i]);
|
||||
if (i > 0) {
|
||||
/* ensure that both src and dst are not NULL */
|
||||
memmove(term.line, term.line + i, row * sizeof(Line));
|
||||
#if SIXEL_PATCH
|
||||
scroll_images(-i);
|
||||
#endif // SIXEL_PATCH
|
||||
term.c.y = row - 1;
|
||||
}
|
||||
for (i += row; i < term.row; i++)
|
||||
free(term.line[i]);
|
||||
/* resize to new height */
|
||||
term.line = xrealloc(term.line, row * sizeof(Line));
|
||||
/* resize to new width */
|
||||
for (i = 0; i < MIN(row, term.row); i++) {
|
||||
term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
|
||||
for (j = term.col; j < col; j++)
|
||||
tclearglyph(&term.line[i][j], 0);
|
||||
}
|
||||
/* allocate any new rows */
|
||||
for (/*i = MIN(row, term.row) */; i < row; i++) {
|
||||
term.line[i] = xmalloc(col * sizeof(Glyph));
|
||||
for (j = 0; j < col; j++)
|
||||
tclearglyph(&term.line[i][j], 0);
|
||||
}
|
||||
/* update cursor */
|
||||
if (term.c.x >= col) {
|
||||
term.c.state &= ~CURSOR_WRAPNEXT;
|
||||
term.c.x = col - 1;
|
||||
} else {
|
||||
UPDATEWRAPNEXT(1, col);
|
||||
}
|
||||
/* update terminal size */
|
||||
term.col = col, term.row = row;
|
||||
/* reset scrolling region */
|
||||
term.top = 0, term.bot = row - 1;
|
||||
|
||||
#if SIXEL_PATCH
|
||||
/* delete or clip images if they are not inside the screen */
|
||||
for (im = term.images; im; im = next) {
|
||||
next = im->next;
|
||||
if (im->x >= term.col || im->y >= term.row || im->y < 0) {
|
||||
delete_image(im);
|
||||
} else {
|
||||
if ((im->cols = MIN(im->x + im->cols, term.col) - im->x) <= 0)
|
||||
delete_image(im);
|
||||
}
|
||||
}
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
/* dirty all lines */
|
||||
tfulldirt();
|
||||
}
|
||||
|
||||
void
|
||||
kscrolldown(const Arg* a)
|
||||
{
|
||||
int n = a->i;
|
||||
|
||||
if (!term.scr || IS_SET(MODE_ALTSCREEN))
|
||||
return;
|
||||
|
||||
if (n < 0)
|
||||
n = MAX(term.row / -n, 1);
|
||||
|
||||
if (n <= term.scr) {
|
||||
term.scr -= n;
|
||||
} else {
|
||||
n = term.scr;
|
||||
term.scr = 0;
|
||||
}
|
||||
|
||||
if (sel.ob.x != -1 && !sel.alt)
|
||||
selmove(-n); /* negate change in term.scr */
|
||||
tfulldirt();
|
||||
|
||||
#if SIXEL_PATCH
|
||||
scroll_images(-1*n);
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
#if OPENURLONCLICK_PATCH
|
||||
if (n > 0)
|
||||
restoremousecursor();
|
||||
#endif // OPENURLONCLICK_PATCH
|
||||
}
|
||||
|
||||
void
|
||||
kscrollup(const Arg* a)
|
||||
{
|
||||
int n = a->i;
|
||||
|
||||
if (!term.histf || IS_SET(MODE_ALTSCREEN))
|
||||
return;
|
||||
|
||||
if (n < 0)
|
||||
n = MAX(term.row / -n, 1);
|
||||
|
||||
if (term.scr + n <= term.histf) {
|
||||
term.scr += n;
|
||||
} else {
|
||||
n = term.histf - term.scr;
|
||||
term.scr = term.histf;
|
||||
}
|
||||
|
||||
if (sel.ob.x != -1 && !sel.alt)
|
||||
selmove(n); /* negate change in term.scr */
|
||||
tfulldirt();
|
||||
|
||||
#if SIXEL_PATCH
|
||||
scroll_images(n);
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
#if OPENURLONCLICK_PATCH
|
||||
if (n > 0)
|
||||
restoremousecursor();
|
||||
#endif // OPENURLONCLICK_PATCH
|
||||
}
|
||||
|
||||
void
|
||||
tscrollup(int top, int bot, int n, int mode)
|
||||
{
|
||||
#if OPENURLONCLICK_PATCH
|
||||
restoremousecursor();
|
||||
#endif //OPENURLONCLICK_PATCH
|
||||
|
||||
int i, j, s;
|
||||
Line temp;
|
||||
int alt = IS_SET(MODE_ALTSCREEN);
|
||||
int savehist = !alt && top == 0 && mode != SCROLL_NOSAVEHIST;
|
||||
int scr = alt ? 0 : term.scr;
|
||||
#if SIXEL_PATCH
|
||||
int itop = top + scr, ibot = bot + scr;
|
||||
ImageList *im, *next;
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
if (n <= 0)
|
||||
return;
|
||||
n = MIN(n, bot-top+1);
|
||||
|
||||
if (savehist) {
|
||||
for (i = 0; i < n; i++) {
|
||||
term.histi = (term.histi + 1) % HISTSIZE;
|
||||
temp = term.hist[term.histi];
|
||||
for (j = 0; j < term.col; j++)
|
||||
tclearglyph(&temp[j], 1);
|
||||
term.hist[term.histi] = term.line[i];
|
||||
term.line[i] = temp;
|
||||
}
|
||||
term.histf = MIN(term.histf + n, HISTSIZE);
|
||||
s = n;
|
||||
if (term.scr) {
|
||||
j = term.scr;
|
||||
term.scr = MIN(j + n, HISTSIZE);
|
||||
s = j + n - term.scr;
|
||||
}
|
||||
if (mode != SCROLL_RESIZE)
|
||||
tfulldirt();
|
||||
} else {
|
||||
tclearregion(0, top, term.col-1, top+n-1, 1);
|
||||
tsetdirt(top + scr, bot + scr);
|
||||
}
|
||||
|
||||
for (i = top; i <= bot-n; i++) {
|
||||
temp = term.line[i];
|
||||
term.line[i] = term.line[i+n];
|
||||
term.line[i+n] = temp;
|
||||
}
|
||||
|
||||
#if SIXEL_PATCH
|
||||
if (alt || !savehist) {
|
||||
/* move images, if they are inside the scrolling region */
|
||||
for (im = term.images; im; im = next) {
|
||||
next = im->next;
|
||||
if (im->y >= itop && im->y <= ibot) {
|
||||
im->y -= n;
|
||||
if (im->y < itop)
|
||||
delete_image(im);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* move images, if they are inside the scrolling region or scrollback */
|
||||
for (im = term.images; im; im = next) {
|
||||
next = im->next;
|
||||
im->y -= scr;
|
||||
if (im->y < 0) {
|
||||
im->y -= n;
|
||||
} else if (im->y >= top && im->y <= bot) {
|
||||
im->y -= n;
|
||||
if (im->y < top)
|
||||
im->y -= top; // move to scrollback
|
||||
}
|
||||
if (im->y < -HISTSIZE)
|
||||
delete_image(im);
|
||||
else
|
||||
im->y += term.scr;
|
||||
}
|
||||
}
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
if (sel.ob.x != -1 && sel.alt == alt) {
|
||||
if (!savehist) {
|
||||
selscroll(top, bot, -n);
|
||||
} else if (s > 0) {
|
||||
selmove(-s);
|
||||
if (-term.scr + sel.nb.y < -term.histf)
|
||||
selremove();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
tscrolldown(int top, int n)
|
||||
{
|
||||
#if OPENURLONCLICK_PATCH
|
||||
restoremousecursor();
|
||||
#endif //OPENURLONCLICK_PATCH
|
||||
|
||||
int i, bot = term.bot;
|
||||
int scr = IS_SET(MODE_ALTSCREEN) ? 0 : term.scr;
|
||||
int itop = top + scr, ibot = bot + scr;
|
||||
Line temp;
|
||||
#if SIXEL_PATCH
|
||||
ImageList *im, *next;
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
if (n <= 0)
|
||||
return;
|
||||
n = MIN(n, bot-top+1);
|
||||
|
||||
tsetdirt(top + scr, bot + scr);
|
||||
tclearregion(0, bot-n+1, term.col-1, bot, 1);
|
||||
|
||||
for (i = bot; i >= top+n; i--) {
|
||||
temp = term.line[i];
|
||||
term.line[i] = term.line[i-n];
|
||||
term.line[i-n] = temp;
|
||||
}
|
||||
|
||||
#if SIXEL_PATCH
|
||||
/* move images, if they are inside the scrolling region */
|
||||
for (im = term.images; im; im = next) {
|
||||
next = im->next;
|
||||
if (im->y >= itop && im->y <= ibot) {
|
||||
im->y += n;
|
||||
if (im->y > ibot)
|
||||
delete_image(im);
|
||||
}
|
||||
}
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
if (sel.ob.x != -1 && sel.alt == IS_SET(MODE_ALTSCREEN))
|
||||
selscroll(top, bot, n);
|
||||
}
|
||||
|
||||
void
|
||||
tresize(int col, int row)
|
||||
{
|
||||
int *bp;
|
||||
|
||||
#if KEYBOARDSELECT_PATCH
|
||||
if (row != term.row || col != term.col)
|
||||
win.mode ^= kbds_keyboardhandler(XK_Escape, NULL, 0, 1);
|
||||
#endif // KEYBOARDSELECT_PATCH
|
||||
|
||||
term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
|
||||
term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
|
||||
if (col > term.col) {
|
||||
bp = term.tabs + term.col;
|
||||
memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
|
||||
while (--bp > term.tabs && !*bp)
|
||||
/* nothing */ ;
|
||||
for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
|
||||
*bp = 1;
|
||||
}
|
||||
|
||||
if (IS_SET(MODE_ALTSCREEN))
|
||||
tresizealt(col, row);
|
||||
else
|
||||
tresizedef(col, row);
|
||||
}
|
||||
|
||||
void
|
||||
tclearregion(int x1, int y1, int x2, int y2, int usecurattr)
|
||||
{
|
||||
int x, y;
|
||||
|
||||
/* regionselected() takes relative coordinates */
|
||||
if (regionselected(x1+term.scr, y1+term.scr, x2+term.scr, y2+term.scr))
|
||||
selremove();
|
||||
|
||||
for (y = y1; y <= y2; y++) {
|
||||
term.dirty[y] = 1;
|
||||
for (x = x1; x <= x2; x++)
|
||||
tclearglyph(&term.line[y][x], usecurattr);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
tnew(int col, int row)
|
||||
{
|
||||
int i, j;
|
||||
for (i = 0; i < 2; i++) {
|
||||
term.line = xmalloc(row * sizeof(Line));
|
||||
for (j = 0; j < row; j++)
|
||||
term.line[j] = xmalloc(col * sizeof(Glyph));
|
||||
term.col = col, term.row = row;
|
||||
tswapscreen();
|
||||
}
|
||||
term.dirty = xmalloc(row * sizeof(*term.dirty));
|
||||
term.tabs = xmalloc(col * sizeof(*term.tabs));
|
||||
for (i = 0; i < HISTSIZE; i++)
|
||||
term.hist[i] = xmalloc(col * sizeof(Glyph));
|
||||
treset();
|
||||
}
|
||||
|
||||
void
|
||||
tdeletechar(int n)
|
||||
{
|
||||
int src, dst, size;
|
||||
Line line;
|
||||
|
||||
if (n <= 0)
|
||||
return;
|
||||
dst = term.c.x;
|
||||
src = MIN(term.c.x + n, term.col);
|
||||
size = term.col - src;
|
||||
if (size > 0) { /* otherwise src would point beyond the array
|
||||
https://stackoverflow.com/questions/29844298 */
|
||||
line = term.line[term.c.y];
|
||||
memmove(&line[dst], &line[src], size * sizeof(Glyph));
|
||||
}
|
||||
tclearregion(dst + size, term.c.y, term.col - 1, term.c.y, 1);
|
||||
}
|
||||
|
||||
void
|
||||
tinsertblank(int n)
|
||||
{
|
||||
int src, dst, size;
|
||||
Line line;
|
||||
|
||||
if (n <= 0)
|
||||
return;
|
||||
dst = MIN(term.c.x + n, term.col);
|
||||
src = term.c.x;
|
||||
size = term.col - dst;
|
||||
|
||||
if (size > 0) { /* otherwise dst would point beyond the array */
|
||||
line = term.line[term.c.y];
|
||||
memmove(&line[dst], &line[src], size * sizeof(Glyph));
|
||||
}
|
||||
tclearregion(src, term.c.y, dst - 1, term.c.y, 1);
|
||||
}
|
||||
|
||||
int
|
||||
tlinelen(Line line)
|
||||
{
|
||||
int i = term.col - 1;
|
||||
|
||||
/* We are using a different algorithm on the alt screen because an
|
||||
* application might use spaces to clear the screen and in that case it is
|
||||
* impossible to find the end of the line when every cell has the ATTR_SET
|
||||
* attribute. The second algorithm is more accurate on the main screen and
|
||||
* and we can use it there. */
|
||||
if (IS_SET(MODE_ALTSCREEN))
|
||||
for (; i >= 0 && !(line[i].mode & ATTR_WRAP) && line[i].u == ' '; i--);
|
||||
else
|
||||
for (; i >= 0 && !(line[i].mode & (ATTR_SET | ATTR_WRAP)); i--);
|
||||
|
||||
return i + 1;
|
||||
}
|
||||
|
||||
int
|
||||
tiswrapped(Line line)
|
||||
{
|
||||
int len = tlinelen(line);
|
||||
|
||||
return len > 0 && (line[len - 1].mode & ATTR_WRAP);
|
||||
}
|
||||
|
||||
char *
|
||||
tgetglyphs(char *buf, const Glyph *gp, const Glyph *lgp)
|
||||
{
|
||||
while (gp <= lgp)
|
||||
if (gp->mode & ATTR_WDUMMY) {
|
||||
gp++;
|
||||
} else {
|
||||
buf += utf8encode((gp++)->u, buf);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
size_t
|
||||
tgetline(char *buf, const Glyph *fgp)
|
||||
{
|
||||
char *ptr;
|
||||
const Glyph *lgp = &fgp[term.col - 1];
|
||||
|
||||
while (lgp > fgp && !(lgp->mode & (ATTR_SET | ATTR_WRAP)))
|
||||
lgp--;
|
||||
ptr = tgetglyphs(buf, fgp, lgp);
|
||||
if (!(lgp->mode & ATTR_WRAP))
|
||||
*(ptr++) = '\n';
|
||||
return ptr - buf;
|
||||
}
|
||||
|
||||
int
|
||||
regionselected(int x1, int y1, int x2, int y2)
|
||||
{
|
||||
if (sel.ob.x == -1 || sel.mode == SEL_EMPTY ||
|
||||
sel.alt != IS_SET(MODE_ALTSCREEN) || sel.nb.y > y2 || sel.ne.y < y1)
|
||||
return 0;
|
||||
|
||||
return (sel.type == SEL_RECTANGULAR) ? sel.nb.x <= x2 && sel.ne.x >= x1
|
||||
: (sel.nb.y != y2 || sel.nb.x <= x2) &&
|
||||
(sel.ne.y != y1 || sel.ne.x >= x1);
|
||||
}
|
||||
|
||||
int
|
||||
selected(int x, int y)
|
||||
{
|
||||
return regionselected(x, y, x, y);
|
||||
}
|
||||
|
||||
void
|
||||
selsnap(int *x, int *y, int direction)
|
||||
{
|
||||
int newx, newy;
|
||||
int rtop = 0, rbot = term.row - 1;
|
||||
int delim, prevdelim, maxlen;
|
||||
const Glyph *gp, *prevgp;
|
||||
|
||||
if (!IS_SET(MODE_ALTSCREEN))
|
||||
rtop += -term.histf + term.scr, rbot += term.scr;
|
||||
|
||||
switch (sel.snap) {
|
||||
case SNAP_WORD:
|
||||
/*
|
||||
* Snap around if the word wraps around at the end or
|
||||
* beginning of a line.
|
||||
*/
|
||||
maxlen = (TLINE(*y)[term.col-2].mode & ATTR_WRAP) ? term.col-1 : term.col;
|
||||
LIMIT(*x, 0, maxlen - 1);
|
||||
prevgp = &TLINE(*y)[*x];
|
||||
prevdelim = ISDELIM(prevgp->u);
|
||||
for (;;) {
|
||||
newx = *x + direction;
|
||||
newy = *y;
|
||||
if (!BETWEEN(newx, 0, maxlen - 1)) {
|
||||
newy += direction;
|
||||
if (!BETWEEN(newy, rtop, rbot))
|
||||
break;
|
||||
|
||||
if (!tiswrapped(TLINE(direction > 0 ? *y : newy)))
|
||||
break;
|
||||
|
||||
maxlen = (TLINE(newy)[term.col-2].mode & ATTR_WRAP) ? term.col-1 : term.col;
|
||||
newx = direction > 0 ? 0 : maxlen - 1;
|
||||
}
|
||||
|
||||
gp = &TLINE(newy)[newx];
|
||||
delim = ISDELIM(gp->u);
|
||||
if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim
|
||||
|| (delim && gp->u != prevgp->u)))
|
||||
break;
|
||||
|
||||
*x = newx;
|
||||
*y = newy;
|
||||
if (!(gp->mode & ATTR_WDUMMY)) {
|
||||
prevgp = gp;
|
||||
prevdelim = delim;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SNAP_LINE:
|
||||
/*
|
||||
* Snap around if the the previous line or the current one
|
||||
* has set ATTR_WRAP at its end. Then the whole next or
|
||||
* previous line will be selected.
|
||||
*/
|
||||
*x = (direction < 0) ? 0 : term.col - 1;
|
||||
if (direction < 0) {
|
||||
for (; *y > rtop; *y -= 1) {
|
||||
if (!tiswrapped(TLINE(*y-1)))
|
||||
break;
|
||||
}
|
||||
} else if (direction > 0) {
|
||||
for (; *y < rbot; *y += 1) {
|
||||
if (!tiswrapped(TLINE(*y)))
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
selscroll(int top, int bot, int n)
|
||||
{
|
||||
/* turn absolute coordinates into relative */
|
||||
top += term.scr, bot += term.scr;
|
||||
|
||||
if (BETWEEN(sel.nb.y, top, bot) != BETWEEN(sel.ne.y, top, bot)) {
|
||||
selclear();
|
||||
} else if (BETWEEN(sel.nb.y, top, bot)) {
|
||||
selmove(n);
|
||||
if (sel.nb.y < top || sel.ne.y > bot)
|
||||
selclear();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
tswapscreen(void)
|
||||
{
|
||||
static Line *altline;
|
||||
static int altcol, altrow;
|
||||
Line *tmpline = term.line;
|
||||
int tmpcol = term.col, tmprow = term.row;
|
||||
#if SIXEL_PATCH
|
||||
ImageList *im = term.images;
|
||||
#endif // SIXEL_PATCH
|
||||
|
||||
term.line = altline;
|
||||
term.col = altcol, term.row = altrow;
|
||||
altline = tmpline;
|
||||
altcol = tmpcol, altrow = tmprow;
|
||||
term.mode ^= MODE_ALTSCREEN;
|
||||
|
||||
#if SIXEL_PATCH
|
||||
term.images = term.images_alt;
|
||||
term.images_alt = im;
|
||||
#endif // SIXEL_PATCH
|
||||
}
|
||||
|
||||
char *
|
||||
getsel(void)
|
||||
{
|
||||
char *str, *ptr;
|
||||
int y, lastx, linelen;
|
||||
const Glyph *gp, *lgp;
|
||||
|
||||
if (sel.ob.x == -1 || sel.alt != IS_SET(MODE_ALTSCREEN))
|
||||
return NULL;
|
||||
|
||||
str = xmalloc((term.col + 1) * (sel.ne.y - sel.nb.y + 1) * UTF_SIZ);
|
||||
ptr = str;
|
||||
|
||||
/* append every set & selected glyph to the selection */
|
||||
for (y = sel.nb.y; y <= sel.ne.y; y++) {
|
||||
Line line = TLINE(y);
|
||||
|
||||
if ((linelen = tlinelen(line)) == 0) {
|
||||
*ptr++ = '\n';
|
||||
continue;
|
||||
}
|
||||
|
||||
if (sel.type == SEL_RECTANGULAR) {
|
||||
gp = &line[sel.nb.x];
|
||||
lastx = sel.ne.x;
|
||||
} else {
|
||||
gp = &line[sel.nb.y == y ? sel.nb.x : 0];
|
||||
lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1;
|
||||
}
|
||||
lgp = &line[MIN(lastx, linelen-1)];
|
||||
|
||||
ptr = tgetglyphs(ptr, gp, lgp);
|
||||
/*
|
||||
* Copy and pasting of line endings is inconsistent
|
||||
* in the inconsistent terminal and GUI world.
|
||||
* The best solution seems like to produce '\n' when
|
||||
* something is copied from st and convert '\n' to
|
||||
* '\r', when something to be pasted is received by
|
||||
* st.
|
||||
* FIXME: Fix the computer world.
|
||||
*/
|
||||
if ((y < sel.ne.y || lastx >= linelen) &&
|
||||
(!(lgp->mode & ATTR_WRAP) || sel.type == SEL_RECTANGULAR))
|
||||
*ptr++ = '\n';
|
||||
}
|
||||
*ptr = '\0';
|
||||
return str;
|
||||
}
|
||||
|
||||
void
|
||||
tdumpline(int n)
|
||||
{
|
||||
char str[(term.col + 1) * UTF_SIZ];
|
||||
|
||||
tprinter(str, tgetline(str, &term.line[n][0]));
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue