/* Combine a UTF-8 zero-width character onto the previous. */
int
screen_write_combine(struct screen_write_ctx *ctx, const struct utf8_data *ud)
{
struct screen *s = ctx->s;
struct grid *gd = s->grid;
struct grid_cell *gc;
struct utf8_data ud1;
/* Can't combine if at 0. */
if (s->cx == 0)
return (-1);
/* Empty data is out. */
if (ud->size == 0)
fatalx("UTF-8 data empty");
/* Retrieve the previous cell. */
gc = grid_view_get_cell(gd, s->cx - 1, s->cy);
grid_cell_get(gc, &ud1);
/* Check there is enough space. */
if (ud1.size + ud->size > sizeof ud1.data)
return (-1);
/* Append the data and set the cell. */
memcpy(ud1.data + ud1.size, ud->data, ud->size);
ud1.size += ud->size;
grid_cell_set(gc, &ud1);
return (0);
}
/* Close UTF-8 string. */
int
input_utf8_close(struct input_ctx *ictx)
{
log_debug("%s", __func__);
utf8_append(&ictx->utf8data, ictx->ch);
grid_cell_set(&ictx->cell, &ictx->utf8data);
screen_write_cell(&ictx->ctx, &ictx->cell);
return (0);
}
void
screen_write_vnputs(struct screen_write_ctx *ctx, ssize_t maxlen,
struct grid_cell *gc, int utf8flag, const char *fmt, va_list ap)
{
char *msg;
struct utf8_data utf8data;
u_char *ptr;
size_t left, size = 0;
xvasprintf(&msg, fmt, ap);
ptr = msg;
while (*ptr != '\0') {
if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
ptr++;
left = strlen(ptr);
if (left < utf8data.size - 1)
break;
while (utf8_append(&utf8data, *ptr))
ptr++;
ptr++;
if (maxlen > 0 &&
size + utf8data.width > (size_t) maxlen) {
while (size < (size_t) maxlen) {
screen_write_putc(ctx, gc, ' ');
size++;
}
break;
}
size += utf8data.width;
grid_cell_set(gc, &utf8data);
screen_write_cell(ctx, gc);
} else {
if (maxlen > 0 && size + 1 > (size_t) maxlen)
break;
if (*ptr == '\001')
gc->attr ^= GRID_ATTR_CHARSET;
else {
size++;
screen_write_putc(ctx, gc, *ptr);
}
ptr++;
}
}
free(msg);
}
/* Write cell data. */
void
screen_write_cell(struct screen_write_ctx *ctx, const struct grid_cell *gc)
{
struct screen *s = ctx->s;
struct grid *gd = s->grid;
struct tty_ctx ttyctx;
u_int width, xx, last;
struct grid_cell tmp_gc, *tmp_gcp;
struct utf8_data ud;
int insert;
/* Ignore padding. */
if (gc->flags & GRID_FLAG_PADDING)
return;
width = grid_cell_width(gc);
/*
* If this is a wide character and there is no room on the screen, for
* the entire character, don't print it.
*/
if (!(s->mode & MODE_WRAP)
&& (width > 1 && (width > screen_size_x(s) ||
(s->cx != screen_size_x(s)
&& s->cx > screen_size_x(s) - width))))
return;
/*
* If the width is zero, combine onto the previous character, if
* there is space.
*/
if (width == 0) {
grid_cell_get(gc, &ud);
if (screen_write_combine(ctx, &ud) == 0) {
screen_write_initctx(ctx, &ttyctx, 0);
tty_write(tty_cmd_utf8character, &ttyctx);
}
return;
}
/* Initialise the redraw context, saving the last cell. */
screen_write_initctx(ctx, &ttyctx, 1);
/* If in insert mode, make space for the cells. */
if ((s->mode & MODE_INSERT) && s->cx <= screen_size_x(s) - width) {
xx = screen_size_x(s) - s->cx - width;
grid_move_cells(s->grid, s->cx + width, s->cx, s->cy, xx);
insert = 1;
} else
insert = 0;
/* Check this will fit on the current line and wrap if not. */
if ((s->mode & MODE_WRAP) && s->cx > screen_size_x(s) - width) {
screen_write_linefeed(ctx, 1);
s->cx = 0; /* carriage return */
}
/* Sanity check cursor position. */
if (s->cx > screen_size_x(s) - width || s->cy > screen_size_y(s) - 1)
return;
/* Handle overwriting of UTF-8 characters. */
screen_write_overwrite(ctx, width);
/*
* If the new character is UTF-8 wide, fill in padding cells. Have
* already ensured there is enough room.
*/
for (xx = s->cx + 1; xx < s->cx + width; xx++) {
tmp_gcp = grid_view_get_cell(gd, xx, s->cy);
if (tmp_gcp != NULL)
tmp_gcp->flags |= GRID_FLAG_PADDING;
}
/* Set the cell. */
grid_view_set_cell(gd, s->cx, s->cy, gc);
/*
* Move the cursor. If not wrapping, stick at the last character and
* replace it.
*/
last = !(s->mode & MODE_WRAP);
if (s->cx <= screen_size_x(s) - last - width)
s->cx += width;
else
s->cx = screen_size_x(s) - last;
/* Draw to the screen if necessary. */
if (insert) {
ttyctx.num = width;
tty_write(tty_cmd_insertcharacter, &ttyctx);
}
if (screen_check_selection(s, s->cx - width, s->cy)) {
memcpy(&tmp_gc, &s->sel.cell, sizeof tmp_gc);
grid_cell_get(gc, &ud);
grid_cell_set(&tmp_gc, &ud);
tmp_gc.flags = gc->flags & ~(GRID_FLAG_FG256|GRID_FLAG_BG256);
tmp_gc.flags |= s->sel.cell.flags &
(GRID_FLAG_FG256|GRID_FLAG_BG256);
ttyctx.cell = &tmp_gc;
tty_write(tty_cmd_cell, &ttyctx);
} else {
ttyctx.cell = gc;
tty_write(tty_cmd_cell, &ttyctx);
}
}
/* Write string, similar to nputs, but with embedded formatting (#[]). */
void printflike5
screen_write_cnputs(struct screen_write_ctx *ctx,
ssize_t maxlen, struct grid_cell *gc, int utf8flag, const char *fmt, ...)
{
struct grid_cell lgc;
struct utf8_data utf8data;
va_list ap;
char *msg;
u_char *ptr, *last;
size_t left, size = 0;
va_start(ap, fmt);
xvasprintf(&msg, fmt, ap);
va_end(ap);
memcpy(&lgc, gc, sizeof lgc);
ptr = msg;
while (*ptr != '\0') {
if (ptr[0] == '#' && ptr[1] == '[') {
ptr += 2;
last = ptr + strcspn(ptr, "]");
if (*last == '\0') {
/* No ]. Not much point in doing anything. */
break;
}
*last = '\0';
style_parse(gc, &lgc, ptr);
ptr = last + 1;
continue;
}
if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
ptr++;
left = strlen(ptr);
if (left < utf8data.size - 1)
break;
while (utf8_append(&utf8data, *ptr))
ptr++;
ptr++;
if (maxlen > 0 &&
size + utf8data.width > (size_t) maxlen) {
while (size < (size_t) maxlen) {
screen_write_putc(ctx, gc, ' ');
size++;
}
break;
}
size += utf8data.width;
grid_cell_set(&lgc, &utf8data);
screen_write_cell(ctx, &lgc);
} else {
if (maxlen > 0 && size + 1 > (size_t) maxlen)
break;
size++;
screen_write_putc(ctx, &lgc, *ptr);
ptr++;
}
}
free(msg);
}
