?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Do not call event_del() for signals after fork(), just use sigaction()
[tmux-openbsd.git] / screen-write.c
blob882fced41e1c49f0c9bb708bb9c77086bc915055
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include <sys/types.h>
20
21 #include <string.h>
22
23 #include "tmux.h"
24
25 void screen_write_initctx(struct screen_write_ctx *, struct tty_ctx *, int);
26 void screen_write_overwrite(struct screen_write_ctx *, u_int);
27 int screen_write_combine(
28 struct screen_write_ctx *, const struct utf8_data *);
29
30 /* Initialise writing with a window. */
31 void
32 screen_write_start(
33 struct screen_write_ctx *ctx, struct window_pane *wp, struct screen *s)
34 {
35 ctx->wp = wp;
36 if (wp != NULL && s == NULL)
37 ctx->s = wp->screen;
38 else
39 ctx->s = s;
40 }
41
42 /* Finish writing. */
43 /* ARGSUSED */
44 void
45 screen_write_stop(unused struct screen_write_ctx *ctx)
46 {
47 }
48
49 /* Write character. */
50 void
51 screen_write_putc(
52 struct screen_write_ctx *ctx, struct grid_cell *gc, u_char ch)
53 {
54 gc->data = ch;
55 screen_write_cell(ctx, gc, NULL);
56 }
57
58 /* Calculate string length, with embedded formatting. */
59 size_t printflike2
60 screen_write_cstrlen(int utf8flag, const char *fmt, ...)
61 {
62 va_list ap;
63 char *msg, *msg2, *ptr, *ptr2;
64 size_t size;
65
66 va_start(ap, fmt);
67 xvasprintf(&msg, fmt, ap);
68 va_end(ap);
69 msg2 = xmalloc(strlen(msg) + 1);
70
71 ptr = msg;
72 ptr2 = msg2;
73 while (*ptr != '\0') {
74 if (ptr[0] == '#' && ptr[1] == '[') {
75 while (*ptr != ']' && *ptr != '\0')
76 ptr++;
77 if (*ptr == ']')
78 ptr++;
79 continue;
80 }
81 *ptr2++ = *ptr++;
82 }
83 *ptr2 = '\0';
84
85 size = screen_write_strlen(utf8flag, "%s", msg2);
86
87 xfree(msg);
88 xfree(msg2);
89
90 return (size);
91 }
92
93 /* Calculate string length. */
94 size_t printflike2
95 screen_write_strlen(int utf8flag, const char *fmt, ...)
96 {
97 va_list ap;
98 char *msg;
99 struct utf8_data utf8data;
100 u_char *ptr;
101 size_t left, size = 0;
102
103 va_start(ap, fmt);
104 xvasprintf(&msg, fmt, ap);
105 va_end(ap);
106
107 ptr = msg;
108 while (*ptr != '\0') {
109 if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
110 ptr++;
111
112 left = strlen(ptr);
113 if (left < utf8data.size - 1)
114 break;
115 while (utf8_append(&utf8data, *ptr))
116 ptr++;
117 ptr++;
118
119 size += utf8data.width;
120 } else {
121 size++;
122 ptr++;
123 }
124 }
125
126 xfree(msg);
127 return (size);
128 }
129
130 /* Write simple string (no UTF-8 or maximum length). */
131 void printflike3
132 screen_write_puts(
133 struct screen_write_ctx *ctx, struct grid_cell *gc, const char *fmt, ...)
134 {
135 va_list ap;
136
137 va_start(ap, fmt);
138 screen_write_vnputs(ctx, -1, gc, 0, fmt, ap);
139 va_end(ap);
140 }
141
142 /* Write string with length limit (-1 for unlimited). */
143 void printflike5
144 screen_write_nputs(struct screen_write_ctx *ctx,
145 ssize_t maxlen, struct grid_cell *gc, int utf8flag, const char *fmt, ...)
146 {
147 va_list ap;
148
149 va_start(ap, fmt);
150 screen_write_vnputs(ctx, maxlen, gc, utf8flag, fmt, ap);
151 va_end(ap);
152 }
153
154 void
155 screen_write_vnputs(struct screen_write_ctx *ctx, ssize_t maxlen,
156 struct grid_cell *gc, int utf8flag, const char *fmt, va_list ap)
157 {
158 char *msg;
159 struct utf8_data utf8data;
160 u_char *ptr;
161 size_t left, size = 0;
162
163 xvasprintf(&msg, fmt, ap);
164
165 ptr = msg;
166 while (*ptr != '\0') {
167 if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
168 ptr++;
169
170 left = strlen(ptr);
171 if (left < utf8data.size - 1)
172 break;
173 while (utf8_append(&utf8data, *ptr))
174 ptr++;
175 ptr++;
176
177 if (maxlen > 0 &&
178 size + utf8data.width > (size_t) maxlen) {
179 while (size < (size_t) maxlen) {
180 screen_write_putc(ctx, gc, ' ');
181 size++;
182 }
183 break;
184 }
185 size += utf8data.width;
186
187 gc->flags |= GRID_FLAG_UTF8;
188 screen_write_cell(ctx, gc, &utf8data);
189 gc->flags &= ~GRID_FLAG_UTF8;
190 } else {
191 if (maxlen > 0 && size + 1 > (size_t) maxlen)
192 break;
193
194 size++;
195 screen_write_putc(ctx, gc, *ptr);
196 ptr++;
197 }
198 }
199
200 xfree(msg);
201 }
202
203 /* Write string, similar to nputs, but with embedded formatting (#[]). */
204 void printflike5
205 screen_write_cnputs(struct screen_write_ctx *ctx,
206 ssize_t maxlen, struct grid_cell *gc, int utf8flag, const char *fmt, ...)
207 {
208 struct grid_cell lgc;
209 struct utf8_data utf8data;
210 va_list ap;
211 char *msg;
212 u_char *ptr, *last;
213 size_t left, size = 0;
214
215 va_start(ap, fmt);
216 xvasprintf(&msg, fmt, ap);
217 va_end(ap);
218
219 memcpy(&lgc, gc, sizeof lgc);
220
221 ptr = msg;
222 while (*ptr != '\0') {
223 if (ptr[0] == '#' && ptr[1] == '[') {
224 ptr += 2;
225 last = ptr + strcspn(ptr, "]");
226 if (*last == '\0') {
227 /* No ]. Not much point in doing anything. */
228 break;
229 }
230 *last = '\0';
231
232 screen_write_parsestyle(gc, &lgc, ptr);
233 ptr = last + 1;
234 continue;
235 }
236
237 if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
238 ptr++;
239
240 left = strlen(ptr);
241 if (left < utf8data.size - 1)
242 break;
243 while (utf8_append(&utf8data, *ptr))
244 ptr++;
245 ptr++;
246
247 if (maxlen > 0 &&
248 size + utf8data.width > (size_t) maxlen) {
249 while (size < (size_t) maxlen) {
250 screen_write_putc(ctx, gc, ' ');
251 size++;
252 }
253 break;
254 }
255 size += utf8data.width;
256
257 lgc.flags |= GRID_FLAG_UTF8;
258 screen_write_cell(ctx, &lgc, &utf8data);
259 lgc.flags &= ~GRID_FLAG_UTF8;
260 } else {
261 if (maxlen > 0 && size + 1 > (size_t) maxlen)
262 break;
263
264 size++;
265 screen_write_putc(ctx, &lgc, *ptr);
266 ptr++;
267 }
268 }
269
270 xfree(msg);
271 }
272
273 /* Parse an embedded style of the form "fg=colour,bg=colour,bright,...". */
274 void
275 screen_write_parsestyle(
276 struct grid_cell *defgc, struct grid_cell *gc, const char *in)
277 {
278 const char delimiters[] = " ,";
279 char tmp[32];
280 int val;
281 size_t end;
282 u_char fg, bg, attr, flags;
283
284 if (*in == '\0')
285 return;
286 if (strchr(delimiters, in[strlen(in) - 1]) != NULL)
287 return;
288
289 fg = gc->fg;
290 bg = gc->bg;
291 attr = gc->attr;
292 flags = gc->flags;
293 do {
294 end = strcspn(in, delimiters);
295 if (end > (sizeof tmp) - 1)
296 return;
297 memcpy(tmp, in, end);
298 tmp[end] = '\0';
299
300 if (strcasecmp(tmp, "default") == 0) {
301 fg = defgc->fg;
302 bg = defgc->bg;
303 attr = defgc->attr;
304 } else if (end > 3 && strncasecmp(tmp + 1, "g=", 2) == 0) {
305 if ((val = colour_fromstring(tmp + 3)) == -1)
306 return;
307 if (*in == 'f' || *in == 'F') {
308 if (val != 8) {
309 if (val & 0x100) {
310 flags |= GRID_FLAG_FG256;
311 val &= ~0x100;
312 } else
313 flags &= ~GRID_FLAG_FG256;
314 fg = val;
315 } else
316 fg = defgc->fg;
317 } else if (*in == 'b' || *in == 'B') {
318 if (val != 8) {
319 if (val & 0x100) {
320 flags |= GRID_FLAG_BG256;
321 val &= ~0x100;
322 } else
323 flags &= ~GRID_FLAG_BG256;
324 bg = val;
325 } else
326 bg = defgc->bg;
327 } else
328 return;
329 } else if (end > 2 && strncasecmp(tmp, "no", 2) == 0) {
330 if ((val = attributes_fromstring(tmp + 2)) == -1)
331 return;
332 attr &= ~val;
333 } else {
334 if ((val = attributes_fromstring(tmp)) == -1)
335 return;
336 attr |= val;
337 }
338
339 in += end + strspn(in + end, delimiters);
340 } while (*in != '\0');
341 gc->fg = fg;
342 gc->bg = bg;
343 gc->attr = attr;
344 gc->flags = flags;
345 }
346
347 /* Copy from another screen. */
348 void
349 screen_write_copy(struct screen_write_ctx *ctx,
350 struct screen *src, u_int px, u_int py, u_int nx, u_int ny)
351 {
352 struct screen *s = ctx->s;
353 struct grid *gd = src->grid;
354 struct grid_line *gl;
355 const struct grid_cell *gc;
356 const struct grid_utf8 *gu;
357 struct utf8_data utf8data;
358 u_int xx, yy, cx, cy, ax, bx;
359
360 cx = s->cx;
361 cy = s->cy;
362 for (yy = py; yy < py + ny; yy++) {
363 gl = &gd->linedata[yy];
364 if (yy < gd->hsize + gd->sy) {
365 /*
366 * Find start and end position and copy between
367 * them. Limit to the real end of the line then use a
368 * clear EOL only if copying to the end, otherwise
369 * could overwrite whatever is there already.
370 */
371 if (px > gl->cellsize)
372 ax = gl->cellsize;
373 else
374 ax = px;
375 if (px + nx == gd->sx && px + nx > gl->cellsize)
376 bx = gl->cellsize;
377 else
378 bx = px + nx;
379
380 for (xx = ax; xx < bx; xx++) {
381 if (xx >= gl->cellsize)
382 gc = &grid_default_cell;
383 else
384 gc = &gl->celldata[xx];
385 if (!(gc->flags & GRID_FLAG_UTF8)) {
386 screen_write_cell(ctx, gc, NULL);
387 continue;
388 }
389 /* Reinject the UTF-8 sequence. */
390 gu = &gl->utf8data[xx];
391 utf8data.size = grid_utf8_copy(
392 gu, utf8data.data, sizeof utf8data.data);
393 utf8data.width = gu->width;
394 screen_write_cell(ctx, gc, &utf8data);
395 }
396 if (px + nx == gd->sx && px + nx > gl->cellsize)
397 screen_write_clearendofline(ctx);
398 } else
399 screen_write_clearline(ctx);
400 cy++;
401 screen_write_cursormove(ctx, cx, cy);
402 }
403 }
404
405 /* Set up context for TTY command. */
406 void
407 screen_write_initctx(
408 struct screen_write_ctx *ctx, struct tty_ctx *ttyctx, int save_last)
409 {
410 struct screen *s = ctx->s;
411 struct grid *gd = s->grid;
412 const struct grid_cell *gc;
413 const struct grid_utf8 *gu;
414 u_int xx;
415
416 ttyctx->wp = ctx->wp;
417
418 ttyctx->ocx = s->cx;
419 ttyctx->ocy = s->cy;
420
421 ttyctx->orlower = s->rlower;
422 ttyctx->orupper = s->rupper;
423
424 if (!save_last)
425 return;
426
427 /* Save the last cell on the screen. */
428 gc = &grid_default_cell;
429 for (xx = 1; xx <= screen_size_x(s); xx++) {
430 gc = grid_view_peek_cell(gd, screen_size_x(s) - xx, s->cy);
431 if (!(gc->flags & GRID_FLAG_PADDING))
432 break;
433 }
434 ttyctx->last_width = xx;
435 memcpy(&ttyctx->last_cell, gc, sizeof ttyctx->last_cell);
436 if (gc->flags & GRID_FLAG_UTF8) {
437 gu = grid_view_peek_utf8(gd, screen_size_x(s) - xx, s->cy);
438 memcpy(&ttyctx->last_utf8, gu, sizeof ttyctx->last_utf8);
439 }
440 }
441
442 /* Cursor up by ny. */
443 void
444 screen_write_cursorup(struct screen_write_ctx *ctx, u_int ny)
445 {
446 struct screen *s = ctx->s;
447
448 if (ny == 0)
449 ny = 1;
450
451 if (s->cy < s->rupper) {
452 /* Above region. */
453 if (ny > s->cy)
454 ny = s->cy;
455 } else {
456 /* Below region. */
457 if (ny > s->cy - s->rupper)
458 ny = s->cy - s->rupper;
459 }
460 if (ny == 0)
461 return;
462
463 s->cy -= ny;
464 }
465
466 /* Cursor down by ny. */
467 void
468 screen_write_cursordown(struct screen_write_ctx *ctx, u_int ny)
469 {
470 struct screen *s = ctx->s;
471
472 if (ny == 0)
473 ny = 1;
474
475 if (s->cy > s->rlower) {
476 /* Below region. */
477 if (ny > screen_size_y(s) - 1 - s->cy)
478 ny = screen_size_y(s) - 1 - s->cy;
479 } else {
480 /* Above region. */
481 if (ny > s->rlower - s->cy)
482 ny = s->rlower - s->cy;
483 }
484 if (ny == 0)
485 return;
486
487 s->cy += ny;
488 }
489
490 /* Cursor right by nx. */
491 void
492 screen_write_cursorright(struct screen_write_ctx *ctx, u_int nx)
493 {
494 struct screen *s = ctx->s;
495
496 if (nx == 0)
497 nx = 1;
498
499 if (nx > screen_size_x(s) - 1 - s->cx)
500 nx = screen_size_x(s) - 1 - s->cx;
501 if (nx == 0)
502 return;
503
504 s->cx += nx;
505 }
506
507 /* Cursor left by nx. */
508 void
509 screen_write_cursorleft(struct screen_write_ctx *ctx, u_int nx)
510 {
511 struct screen *s = ctx->s;
512
513 if (nx == 0)
514 nx = 1;
515
516 if (nx > s->cx)
517 nx = s->cx;
518 if (nx == 0)
519 return;
520
521 s->cx -= nx;
522 }
523
524 /* Backspace; cursor left unless at start of wrapped line when can move up. */
525 void
526 screen_write_backspace(struct screen_write_ctx *ctx)
527 {
528 struct screen *s = ctx->s;
529 struct grid_line *gl;
530
531 if (s->cx == 0) {
532 if (s->cy == 0)
533 return;
534 gl = &s->grid->linedata[s->grid->hsize + s->cy - 1];
535 if (gl->flags & GRID_LINE_WRAPPED) {
536 s->cy--;
537 s->cx = screen_size_x(s) - 1;
538 }
539 } else
540 s->cx--;
541 }
542
543 /* VT100 alignment test. */
544 void
545 screen_write_alignmenttest(struct screen_write_ctx *ctx)
546 {
547 struct screen *s = ctx->s;
548 struct tty_ctx ttyctx;
549 struct grid_cell gc;
550 u_int xx, yy;
551
552 screen_write_initctx(ctx, &ttyctx, 0);
553
554 memcpy(&gc, &grid_default_cell, sizeof gc);
555 gc.data = 'E';
556
557 for (yy = 0; yy < screen_size_y(s); yy++) {
558 for (xx = 0; xx < screen_size_x(s); xx++)
559 grid_view_set_cell(s->grid, xx, yy, &gc);
560 }
561
562 s->cx = 0;
563 s->cy = 0;
564
565 s->rupper = 0;
566
567 s->rlower = screen_size_y(s) - 1;
568
569 tty_write(tty_cmd_alignmenttest, &ttyctx);
570 }
571
572 /* Insert nx characters. */
573 void
574 screen_write_insertcharacter(struct screen_write_ctx *ctx, u_int nx)
575 {
576 struct screen *s = ctx->s;
577 struct tty_ctx ttyctx;
578
579 if (nx == 0)
580 nx = 1;
581
582 if (nx > screen_size_x(s) - s->cx)
583 nx = screen_size_x(s) - s->cx;
584 if (nx == 0)
585 return;
586
587 screen_write_initctx(ctx, &ttyctx, 0);
588
589 if (s->cx <= screen_size_x(s) - 1)
590 grid_view_insert_cells(s->grid, s->cx, s->cy, nx);
591
592 ttyctx.num = nx;
593 tty_write(tty_cmd_insertcharacter, &ttyctx);
594 }
595
596 /* Delete nx characters. */
597 void
598 screen_write_deletecharacter(struct screen_write_ctx *ctx, u_int nx)
599 {
600 struct screen *s = ctx->s;
601 struct tty_ctx ttyctx;
602
603 if (nx == 0)
604 nx = 1;
605
606 if (nx > screen_size_x(s) - s->cx)
607 nx = screen_size_x(s) - s->cx;
608 if (nx == 0)
609 return;
610
611 screen_write_initctx(ctx, &ttyctx, 0);
612
613 if (s->cx <= screen_size_x(s) - 1)
614 grid_view_delete_cells(s->grid, s->cx, s->cy, nx);
615
616 ttyctx.num = nx;
617 tty_write(tty_cmd_deletecharacter, &ttyctx);
618 }
619
620 /* Insert ny lines. */
621 void
622 screen_write_insertline(struct screen_write_ctx *ctx, u_int ny)
623 {
624 struct screen *s = ctx->s;
625 struct tty_ctx ttyctx;
626
627 if (ny == 0)
628 ny = 1;
629
630 if (s->cy < s->rupper || s->cy > s->rlower) {
631 if (ny > screen_size_y(s) - s->cy)
632 ny = screen_size_y(s) - s->cy;
633 if (ny == 0)
634 return;
635
636 screen_write_initctx(ctx, &ttyctx, 0);
637
638 grid_view_insert_lines(s->grid, s->cy, ny);
639
640 ttyctx.num = ny;
641 tty_write(tty_cmd_insertline, &ttyctx);
642 return;
643 }
644
645 if (ny > s->rlower + 1 - s->cy)
646 ny = s->rlower + 1 - s->cy;
647 if (ny == 0)
648 return;
649
650 screen_write_initctx(ctx, &ttyctx, 0);
651
652 if (s->cy < s->rupper || s->cy > s->rlower)
653 grid_view_insert_lines(s->grid, s->cy, ny);
654 else
655 grid_view_insert_lines_region(s->grid, s->rlower, s->cy, ny);
656
657 ttyctx.num = ny;
658 tty_write(tty_cmd_insertline, &ttyctx);
659 }
660
661 /* Delete ny lines. */
662 void
663 screen_write_deleteline(struct screen_write_ctx *ctx, u_int ny)
664 {
665 struct screen *s = ctx->s;
666 struct tty_ctx ttyctx;
667
668 if (ny == 0)
669 ny = 1;
670
671 if (s->cy < s->rupper || s->cy > s->rlower) {
672 if (ny > screen_size_y(s) - s->cy)
673 ny = screen_size_y(s) - s->cy;
674 if (ny == 0)
675 return;
676
677 screen_write_initctx(ctx, &ttyctx, 0);
678
679 grid_view_delete_lines(s->grid, s->cy, ny);
680
681 ttyctx.num = ny;
682 tty_write(tty_cmd_deleteline, &ttyctx);
683 return;
684 }
685
686 if (ny > s->rlower + 1 - s->cy)
687 ny = s->rlower + 1 - s->cy;
688 if (ny == 0)
689 return;
690
691 screen_write_initctx(ctx, &ttyctx, 0);
692
693 if (s->cy < s->rupper || s->cy > s->rlower)
694 grid_view_delete_lines(s->grid, s->cy, ny);
695 else
696 grid_view_delete_lines_region(s->grid, s->rlower, s->cy, ny);
697
698 ttyctx.num = ny;
699 tty_write(tty_cmd_deleteline, &ttyctx);
700 }
701
702 /* Clear line at cursor. */
703 void
704 screen_write_clearline(struct screen_write_ctx *ctx)
705 {
706 struct screen *s = ctx->s;
707 struct tty_ctx ttyctx;
708
709 screen_write_initctx(ctx, &ttyctx, 0);
710
711 grid_view_clear(s->grid, 0, s->cy, screen_size_x(s), 1);
712
713 tty_write(tty_cmd_clearline, &ttyctx);
714 }
715
716 /* Clear to end of line from cursor. */
717 void
718 screen_write_clearendofline(struct screen_write_ctx *ctx)
719 {
720 struct screen *s = ctx->s;
721 struct tty_ctx ttyctx;
722 u_int sx;
723
724 screen_write_initctx(ctx, &ttyctx, 0);
725
726 sx = screen_size_x(s);
727
728 if (s->cx <= sx - 1)
729 grid_view_clear(s->grid, s->cx, s->cy, sx - s->cx, 1);
730
731 tty_write(tty_cmd_clearendofline, &ttyctx);
732 }
733
734 /* Clear to start of line from cursor. */
735 void
736 screen_write_clearstartofline(struct screen_write_ctx *ctx)
737 {
738 struct screen *s = ctx->s;
739 struct tty_ctx ttyctx;
740 u_int sx;
741
742 screen_write_initctx(ctx, &ttyctx, 0);
743
744 sx = screen_size_x(s);
745
746 if (s->cx > sx - 1)
747 grid_view_clear(s->grid, 0, s->cy, sx, 1);
748 else
749 grid_view_clear(s->grid, 0, s->cy, s->cx + 1, 1);
750
751 tty_write(tty_cmd_clearstartofline, &ttyctx);
752 }
753
754 /* Move cursor to px,py. */
755 void
756 screen_write_cursormove(struct screen_write_ctx *ctx, u_int px, u_int py)
757 {
758 struct screen *s = ctx->s;
759
760 if (px > screen_size_x(s) - 1)
761 px = screen_size_x(s) - 1;
762 if (py > screen_size_y(s) - 1)
763 py = screen_size_y(s) - 1;
764
765 s->cx = px;
766 s->cy = py;
767 }
768
769 /* Set cursor mode. */
770 void
771 screen_write_cursormode(struct screen_write_ctx *ctx, int state)
772 {
773 struct screen *s = ctx->s;
774
775 if (state)
776 s->mode |= MODE_CURSOR;
777 else
778 s->mode &= ~MODE_CURSOR;
779 }
780
781 /* Reverse index (up with scroll). */
782 void
783 screen_write_reverseindex(struct screen_write_ctx *ctx)
784 {
785 struct screen *s = ctx->s;
786 struct tty_ctx ttyctx;
787
788 screen_write_initctx(ctx, &ttyctx, 0);
789
790 if (s->cy == s->rupper)
791 grid_view_scroll_region_down(s->grid, s->rupper, s->rlower);
792 else if (s->cy > 0)
793 s->cy--;
794
795 tty_write(tty_cmd_reverseindex, &ttyctx);
796 }
797
798 /* Set scroll region. */
799 void
800 screen_write_scrollregion(
801 struct screen_write_ctx *ctx, u_int rupper, u_int rlower)
802 {
803 struct screen *s = ctx->s;
804
805 if (rupper > screen_size_y(s) - 1)
806 rupper = screen_size_y(s) - 1;
807 if (rlower > screen_size_y(s) - 1)
808 rlower = screen_size_y(s) - 1;
809 if (rupper >= rlower) /* cannot be one line */
810 return;
811
812 /* Cursor moves to top-left. */
813 s->cx = 0;
814 s->cy = 0;
815
816 s->rupper = rupper;
817 s->rlower = rlower;
818 }
819
820 /* Set insert mode. */
821 void
822 screen_write_insertmode(struct screen_write_ctx *ctx, int state)
823 {
824 struct screen *s = ctx->s;
825
826 if (state)
827 s->mode |= MODE_INSERT;
828 else
829 s->mode &= ~MODE_INSERT;
830 }
831
832 /* Set mouse mode. */
833 void
834 screen_write_mousemode(struct screen_write_ctx *ctx, int state)
835 {
836 struct screen *s = ctx->s;
837
838 if (state)
839 s->mode |= MODE_MOUSE;
840 else
841 s->mode &= ~MODE_MOUSE;
842 }
843
844 /* Line feed. */
845 void
846 screen_write_linefeed(struct screen_write_ctx *ctx, int wrapped)
847 {
848 struct screen *s = ctx->s;
849 struct grid_line *gl;
850 struct tty_ctx ttyctx;
851
852 screen_write_initctx(ctx, &ttyctx, 0);
853
854 gl = &s->grid->linedata[s->grid->hsize + s->cy];
855 if (wrapped)
856 gl->flags |= GRID_LINE_WRAPPED;
857 else
858 gl->flags &= ~GRID_LINE_WRAPPED;
859
860 if (s->cy == s->rlower)
861 grid_view_scroll_region_up(s->grid, s->rupper, s->rlower);
862 else if (s->cy < screen_size_y(s) - 1)
863 s->cy++;
864
865 ttyctx.num = wrapped;
866 tty_write(tty_cmd_linefeed, &ttyctx);
867 }
868
869 /* Carriage return (cursor to start of line). */
870 void
871 screen_write_carriagereturn(struct screen_write_ctx *ctx)
872 {
873 struct screen *s = ctx->s;
874
875 s->cx = 0;
876 }
877
878 /* Set keypad cursor keys mode. */
879 void
880 screen_write_kcursormode(struct screen_write_ctx *ctx, int state)
881 {
882 struct screen *s = ctx->s;
883
884 if (state)
885 s->mode |= MODE_KCURSOR;
886 else
887 s->mode &= ~MODE_KCURSOR;
888 }
889
890 /* Set keypad number keys mode. */
891 void
892 screen_write_kkeypadmode(struct screen_write_ctx *ctx, int state)
893 {
894 struct screen *s = ctx->s;
895
896 if (state)
897 s->mode |= MODE_KKEYPAD;
898 else
899 s->mode &= ~MODE_KKEYPAD;
900 }
901
902 /* Clear to end of screen from cursor. */
903 void
904 screen_write_clearendofscreen(struct screen_write_ctx *ctx)
905 {
906 struct screen *s = ctx->s;
907 struct tty_ctx ttyctx;
908 u_int sx, sy;
909
910 screen_write_initctx(ctx, &ttyctx, 0);
911
912 sx = screen_size_x(s);
913 sy = screen_size_y(s);
914
915 if (s->cx <= sx - 1)
916 grid_view_clear(s->grid, s->cx, s->cy, sx - s->cx, 1);
917 grid_view_clear(s->grid, 0, s->cy + 1, sx, sy - (s->cy + 1));
918
919 tty_write(tty_cmd_clearendofscreen, &ttyctx);
920 }
921
922 /* Clear to start of screen. */
923 void
924 screen_write_clearstartofscreen(struct screen_write_ctx *ctx)
925 {
926 struct screen *s = ctx->s;
927 struct tty_ctx ttyctx;
928 u_int sx;
929
930 screen_write_initctx(ctx, &ttyctx, 0);
931
932 sx = screen_size_x(s);
933
934 if (s->cy > 0)
935 grid_view_clear(s->grid, 0, 0, sx, s->cy);
936 if (s->cx > sx - 1)
937 grid_view_clear(s->grid, 0, s->cy, sx, 1);
938 else
939 grid_view_clear(s->grid, 0, s->cy, s->cx + 1, 1);
940
941 tty_write(tty_cmd_clearstartofscreen, &ttyctx);
942 }
943
944 /* Clear entire screen. */
945 void
946 screen_write_clearscreen(struct screen_write_ctx *ctx)
947 {
948 struct screen *s = ctx->s;
949 struct tty_ctx ttyctx;
950
951 screen_write_initctx(ctx, &ttyctx, 0);
952
953 grid_view_clear(s->grid, 0, 0, screen_size_x(s), screen_size_y(s));
954
955 tty_write(tty_cmd_clearscreen, &ttyctx);
956 }
957
958 /* Write cell data. */
959 void
960 screen_write_cell(struct screen_write_ctx *ctx,
961 const struct grid_cell *gc, const struct utf8_data *utf8data)
962 {
963 struct screen *s = ctx->s;
964 struct grid *gd = s->grid;
965 struct tty_ctx ttyctx;
966 struct grid_utf8 gu;
967 u_int width, xx;
968 struct grid_cell tmp_gc, *tmp_gcp;
969 int insert = 0;
970
971 /* Ignore padding. */
972 if (gc->flags & GRID_FLAG_PADDING)
973 return;
974
975 /* Find character width. */
976 if (gc->flags & GRID_FLAG_UTF8)
977 width = utf8data->width;
978 else
979 width = 1;
980
981 /*
982 * If this is a wide character and there is no room on the screen, for
983 * the entire character, don't print it.
984 */
985 if (width > 1 && (width > screen_size_x(s) ||
986 (s->cx != screen_size_x(s) && s->cx > screen_size_x(s) - width)))
987 return;
988
989 /*
990 * If the width is zero, combine onto the previous character, if
991 * there is space.
992 */
993 if (width == 0) {
994 if (screen_write_combine(ctx, utf8data) == 0) {
995 screen_write_initctx(ctx, &ttyctx, 0);
996 tty_write(tty_cmd_utf8character, &ttyctx);
997 }
998 return;
999 }
1000
1001 /* Initialise the redraw context, saving the last cell. */
1002 screen_write_initctx(ctx, &ttyctx, 1);
1003
1004 /* If in insert mode, make space for the cells. */
1005 if (s->mode & MODE_INSERT && s->cx <= screen_size_x(s) - width) {
1006 xx = screen_size_x(s) - s->cx - width;
1007 grid_move_cells(s->grid, s->cx + width, s->cx, s->cy, xx);
1008 insert = 1;
1009 }
1010
1011 /* Check this will fit on the current line and wrap if not. */
1012 if ((s->mode & MODE_WRAP) && s->cx > screen_size_x(s) - width) {
1013 screen_write_linefeed(ctx, 1);
1014 s->cx = 0; /* carriage return */
1015 }
1016
1017 /* Sanity checks. */
1018 if (((s->mode & MODE_WRAP) && s->cx > screen_size_x(s) - 1)
1019 || s->cy > screen_size_y(s) - 1)
1020 return;
1021
1022 /* Handle overwriting of UTF-8 characters. */
1023 screen_write_overwrite(ctx, width);
1024
1025 /*
1026 * If the new character is UTF-8 wide, fill in padding cells. Have
1027 * already ensured there is enough room.
1028 */
1029 for (xx = s->cx + 1; xx < s->cx + width; xx++) {
1030 tmp_gcp = grid_view_get_cell(gd, xx, s->cy);
1031 if (tmp_gcp != NULL)
1032 tmp_gcp->flags |= GRID_FLAG_PADDING;
1033 }
1034
1035 /* Set the cell. */
1036 grid_view_set_cell(gd, s->cx, s->cy, gc);
1037 if (gc->flags & GRID_FLAG_UTF8) {
1038 /* Construct UTF-8 and write it. */
1039 grid_utf8_set(&gu, utf8data);
1040 grid_view_set_utf8(gd, s->cx, s->cy, &gu);
1041 }
1042
1043 /* Move the cursor. */
1044 s->cx += width;
1045
1046 /* Draw to the screen if necessary. */
1047 if (insert) {
1048 ttyctx.num = width;
1049 tty_write(tty_cmd_insertcharacter, &ttyctx);
1050 }
1051 ttyctx.utf8 = &gu;
1052 if (screen_check_selection(s, s->cx - width, s->cy)) {
1053 memcpy(&tmp_gc, &s->sel.cell, sizeof tmp_gc);
1054 tmp_gc.data = gc->data;
1055 tmp_gc.flags = gc->flags &
1056 ~(GRID_FLAG_FG256|GRID_FLAG_BG256);
1057 tmp_gc.flags |= s->sel.cell.flags &
1058 (GRID_FLAG_FG256|GRID_FLAG_BG256);
1059 ttyctx.cell = &tmp_gc;
1060 tty_write(tty_cmd_cell, &ttyctx);
1061 } else {
1062 ttyctx.cell = gc;
1063 tty_write(tty_cmd_cell, &ttyctx);
1064 }
1065 }
1066
1067 /* Combine a UTF-8 zero-width character onto the previous. */
1068 int
1069 screen_write_combine(
1070 struct screen_write_ctx *ctx, const struct utf8_data *utf8data)
1071 {
1072 struct screen *s = ctx->s;
1073 struct grid *gd = s->grid;
1074 struct grid_cell *gc;
1075 struct grid_utf8 *gu, tmp_gu;
1076 u_int i;
1077
1078 /* Can't combine if at 0. */
1079 if (s->cx == 0)
1080 return (-1);
1081
1082 /* Empty utf8data is out. */
1083 if (utf8data->size == 0)
1084 fatalx("UTF-8 data empty");
1085
1086 /* Retrieve the previous cell and convert to UTF-8 if not already. */
1087 gc = grid_view_get_cell(gd, s->cx - 1, s->cy);
1088 if (!(gc->flags & GRID_FLAG_UTF8)) {
1089 tmp_gu.data[0] = gc->data;
1090 tmp_gu.data[1] = 0xff;
1091 tmp_gu.width = 1;
1092
1093 grid_view_set_utf8(gd, s->cx - 1, s->cy, &tmp_gu);
1094 gc->flags |= GRID_FLAG_UTF8;
1095 }
1096
1097 /* Append the current cell. */
1098 gu = grid_view_get_utf8(gd, s->cx - 1, s->cy);
1099 if (grid_utf8_append(gu, utf8data) != 0) {
1100 /* Failed: scrap this character and replace with underscores. */
1101 if (gu->width == 1) {
1102 gc->data = '_';
1103 gc->flags &= ~GRID_FLAG_UTF8;
1104 } else {
1105 for (i = 0; i < gu->width && i != sizeof gu->data; i++)
1106 gu->data[i] = '_';
1107 if (i != sizeof gu->data)
1108 gu->data[i] = 0xff;
1109 gu->width = i;
1110 }
1111 }
1112
1113 return (0);
1114 }
1115
1116 /*
1117 * UTF-8 wide characters are a bit of an annoyance. They take up more than one
1118 * cell on the screen, so following cells must not be drawn by marking them as
1119 * padding.
1120 *
1121 * So far, so good. The problem is, when overwriting a padding cell, or a UTF-8
1122 * character, it is necessary to also overwrite any other cells which covered
1123 * by the same character.
1124 */
1125 void
1126 screen_write_overwrite(struct screen_write_ctx *ctx, u_int width)
1127 {
1128 struct screen *s = ctx->s;
1129 struct grid *gd = s->grid;
1130 const struct grid_cell *gc;
1131 u_int xx;
1132
1133 gc = grid_view_peek_cell(gd, s->cx, s->cy);
1134 if (gc->flags & GRID_FLAG_PADDING) {
1135 /*
1136 * A padding cell, so clear any following and leading padding
1137 * cells back to the character. Don't overwrite the current
1138 * cell as that happens later anyway.
1139 */
1140 xx = s->cx + 1;
1141 while (--xx > 0) {
1142 gc = grid_view_peek_cell(gd, xx, s->cy);
1143 if (!(gc->flags & GRID_FLAG_PADDING))
1144 break;
1145 grid_view_set_cell(gd, xx, s->cy, &grid_default_cell);
1146 }
1147
1148 /* Overwrite the character at the start of this padding. */
1149 grid_view_set_cell(gd, xx, s->cy, &grid_default_cell);
1150 }
1151
1152 /*
1153 * Overwrite any padding cells that belong to a UTF-8 character
1154 * we'll be overwriting with the current character.
1155 */
1156 xx = s->cx + width - 1;
1157 while (++xx < screen_size_x(s)) {
1158 gc = grid_view_peek_cell(gd, xx, s->cy);
1159 if (!(gc->flags & GRID_FLAG_PADDING))
1160 break;
1161 grid_view_set_cell(gd, xx, s->cy, &grid_default_cell);
1162 }
1163 }