?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Another memory leak from Tiago Cunha.
[tmux-openbsd.git] / screen-write.c
blob60623701985c5835f4d8c7460dcdbfaf76dc9bab
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 UTF-8 mouse mode. */
833 void
834 screen_write_utf8mousemode(struct screen_write_ctx *ctx, int state)
835 {
836 struct screen *s = ctx->s;
837
838 if (state)
839 s->mode |= MODE_MOUSE_UTF8;
840 else
841 s->mode &= ~MODE_MOUSE_UTF8;
842 }
843
844 /* Set mouse mode off. */
845 void
846 screen_write_mousemode_off(struct screen_write_ctx *ctx)
847 {
848 struct screen *s = ctx->s;
849
850 s->mode &= ~ALL_MOUSE_MODES;
851 }
852
853 /* Set mouse mode on. */
854 void
855 screen_write_mousemode_on(struct screen_write_ctx *ctx, int mode)
856 {
857 struct screen *s = ctx->s;
858
859 s->mode &= ~ALL_MOUSE_MODES;
860 s->mode |= mode;
861 }
862
863 /* Line feed. */
864 void
865 screen_write_linefeed(struct screen_write_ctx *ctx, int wrapped)
866 {
867 struct screen *s = ctx->s;
868 struct grid_line *gl;
869 struct tty_ctx ttyctx;
870
871 screen_write_initctx(ctx, &ttyctx, 0);
872
873 gl = &s->grid->linedata[s->grid->hsize + s->cy];
874 if (wrapped)
875 gl->flags |= GRID_LINE_WRAPPED;
876 else
877 gl->flags &= ~GRID_LINE_WRAPPED;
878
879 if (s->cy == s->rlower)
880 grid_view_scroll_region_up(s->grid, s->rupper, s->rlower);
881 else if (s->cy < screen_size_y(s) - 1)
882 s->cy++;
883
884 ttyctx.num = wrapped;
885 tty_write(tty_cmd_linefeed, &ttyctx);
886 }
887
888 /* Carriage return (cursor to start of line). */
889 void
890 screen_write_carriagereturn(struct screen_write_ctx *ctx)
891 {
892 struct screen *s = ctx->s;
893
894 s->cx = 0;
895 }
896
897 /* Set keypad cursor keys mode. */
898 void
899 screen_write_kcursormode(struct screen_write_ctx *ctx, int state)
900 {
901 struct screen *s = ctx->s;
902
903 if (state)
904 s->mode |= MODE_KCURSOR;
905 else
906 s->mode &= ~MODE_KCURSOR;
907 }
908
909 /* Set keypad number keys mode. */
910 void
911 screen_write_kkeypadmode(struct screen_write_ctx *ctx, int state)
912 {
913 struct screen *s = ctx->s;
914
915 if (state)
916 s->mode |= MODE_KKEYPAD;
917 else
918 s->mode &= ~MODE_KKEYPAD;
919 }
920
921 /* Clear to end of screen from cursor. */
922 void
923 screen_write_clearendofscreen(struct screen_write_ctx *ctx)
924 {
925 struct screen *s = ctx->s;
926 struct tty_ctx ttyctx;
927 u_int sx, sy;
928
929 screen_write_initctx(ctx, &ttyctx, 0);
930
931 sx = screen_size_x(s);
932 sy = screen_size_y(s);
933
934 /* Scroll into history if it is enabled and clearing entire screen. */
935 if (s->cy == 0 && s->grid->flags & GRID_HISTORY)
936 grid_view_clear_history(s->grid);
937 else {
938 if (s->cx <= sx - 1)
939 grid_view_clear(s->grid, s->cx, s->cy, sx - s->cx, 1);
940 grid_view_clear(s->grid, 0, s->cy + 1, sx, sy - (s->cy + 1));
941 }
942
943 tty_write(tty_cmd_clearendofscreen, &ttyctx);
944 }
945
946 /* Clear to start of screen. */
947 void
948 screen_write_clearstartofscreen(struct screen_write_ctx *ctx)
949 {
950 struct screen *s = ctx->s;
951 struct tty_ctx ttyctx;
952 u_int sx;
953
954 screen_write_initctx(ctx, &ttyctx, 0);
955
956 sx = screen_size_x(s);
957
958 if (s->cy > 0)
959 grid_view_clear(s->grid, 0, 0, sx, s->cy);
960 if (s->cx > sx - 1)
961 grid_view_clear(s->grid, 0, s->cy, sx, 1);
962 else
963 grid_view_clear(s->grid, 0, s->cy, s->cx + 1, 1);
964
965 tty_write(tty_cmd_clearstartofscreen, &ttyctx);
966 }
967
968 /* Clear entire screen. */
969 void
970 screen_write_clearscreen(struct screen_write_ctx *ctx)
971 {
972 struct screen *s = ctx->s;
973 struct tty_ctx ttyctx;
974
975 screen_write_initctx(ctx, &ttyctx, 0);
976
977 /* Scroll into history if it is enabled. */
978 if (s->grid->flags & GRID_HISTORY)
979 grid_view_clear_history(s->grid);
980 else {
981 grid_view_clear(
982 s->grid, 0, 0, screen_size_x(s), screen_size_y(s));
983 }
984
985 tty_write(tty_cmd_clearscreen, &ttyctx);
986 }
987
988 /* Write cell data. */
989 void
990 screen_write_cell(struct screen_write_ctx *ctx,
991 const struct grid_cell *gc, const struct utf8_data *utf8data)
992 {
993 struct screen *s = ctx->s;
994 struct grid *gd = s->grid;
995 struct tty_ctx ttyctx;
996 struct grid_utf8 gu;
997 u_int width, xx;
998 struct grid_cell tmp_gc, *tmp_gcp;
999 int insert = 0;
1000
1001 /* Ignore padding. */
1002 if (gc->flags & GRID_FLAG_PADDING)
1003 return;
1004
1005 /* Find character width. */
1006 if (gc->flags & GRID_FLAG_UTF8)
1007 width = utf8data->width;
1008 else
1009 width = 1;
1010
1011 /*
1012 * If this is a wide character and there is no room on the screen, for
1013 * the entire character, don't print it.
1014 */
1015 if (!(s->mode & MODE_WRAP)
1016 && (width > 1 && (width > screen_size_x(s) ||
1017 (s->cx != screen_size_x(s)
1018 && s->cx > screen_size_x(s) - width))))
1019 return;
1020
1021 /*
1022 * If the width is zero, combine onto the previous character, if
1023 * there is space.
1024 */
1025 if (width == 0) {
1026 if (screen_write_combine(ctx, utf8data) == 0) {
1027 screen_write_initctx(ctx, &ttyctx, 0);
1028 tty_write(tty_cmd_utf8character, &ttyctx);
1029 }
1030 return;
1031 }
1032
1033 /* Initialise the redraw context, saving the last cell. */
1034 screen_write_initctx(ctx, &ttyctx, 1);
1035
1036 /* If in insert mode, make space for the cells. */
1037 if (s->mode & MODE_INSERT && s->cx <= screen_size_x(s) - width) {
1038 xx = screen_size_x(s) - s->cx - width;
1039 grid_move_cells(s->grid, s->cx + width, s->cx, s->cy, xx);
1040 insert = 1;
1041 }
1042
1043 /* Check this will fit on the current line and wrap if not. */
1044 if ((s->mode & MODE_WRAP) && s->cx > screen_size_x(s) - width) {
1045 screen_write_linefeed(ctx, 1);
1046 s->cx = 0; /* carriage return */
1047 }
1048
1049 /* Sanity checks. */
1050 if (((s->mode & MODE_WRAP) && s->cx > screen_size_x(s) - width)
1051 || s->cy > screen_size_y(s) - 1)
1052 return;
1053
1054 /* Handle overwriting of UTF-8 characters. */
1055 screen_write_overwrite(ctx, width);
1056
1057 /*
1058 * If the new character is UTF-8 wide, fill in padding cells. Have
1059 * already ensured there is enough room.
1060 */
1061 for (xx = s->cx + 1; xx < s->cx + width; xx++) {
1062 tmp_gcp = grid_view_get_cell(gd, xx, s->cy);
1063 if (tmp_gcp != NULL)
1064 tmp_gcp->flags |= GRID_FLAG_PADDING;
1065 }
1066
1067 /* Set the cell. */
1068 grid_view_set_cell(gd, s->cx, s->cy, gc);
1069 if (gc->flags & GRID_FLAG_UTF8) {
1070 /* Construct UTF-8 and write it. */
1071 grid_utf8_set(&gu, utf8data);
1072 grid_view_set_utf8(gd, s->cx, s->cy, &gu);
1073 }
1074
1075 /* Move the cursor. */
1076 s->cx += width;
1077
1078 /* Draw to the screen if necessary. */
1079 if (insert) {
1080 ttyctx.num = width;
1081 tty_write(tty_cmd_insertcharacter, &ttyctx);
1082 }
1083 ttyctx.utf8 = &gu;
1084 if (screen_check_selection(s, s->cx - width, s->cy)) {
1085 memcpy(&tmp_gc, &s->sel.cell, sizeof tmp_gc);
1086 tmp_gc.data = gc->data;
1087 tmp_gc.flags = gc->flags &
1088 ~(GRID_FLAG_FG256|GRID_FLAG_BG256);
1089 tmp_gc.flags |= s->sel.cell.flags &
1090 (GRID_FLAG_FG256|GRID_FLAG_BG256);
1091 ttyctx.cell = &tmp_gc;
1092 tty_write(tty_cmd_cell, &ttyctx);
1093 } else {
1094 ttyctx.cell = gc;
1095 tty_write(tty_cmd_cell, &ttyctx);
1096 }
1097 }
1098
1099 /* Combine a UTF-8 zero-width character onto the previous. */
1100 int
1101 screen_write_combine(
1102 struct screen_write_ctx *ctx, const struct utf8_data *utf8data)
1103 {
1104 struct screen *s = ctx->s;
1105 struct grid *gd = s->grid;
1106 struct grid_cell *gc;
1107 struct grid_utf8 *gu, tmp_gu;
1108 u_int i;
1109
1110 /* Can't combine if at 0. */
1111 if (s->cx == 0)
1112 return (-1);
1113
1114 /* Empty utf8data is out. */
1115 if (utf8data->size == 0)
1116 fatalx("UTF-8 data empty");
1117
1118 /* Retrieve the previous cell and convert to UTF-8 if not already. */
1119 gc = grid_view_get_cell(gd, s->cx - 1, s->cy);
1120 if (!(gc->flags & GRID_FLAG_UTF8)) {
1121 tmp_gu.data[0] = gc->data;
1122 tmp_gu.data[1] = 0xff;
1123 tmp_gu.width = 1;
1124
1125 grid_view_set_utf8(gd, s->cx - 1, s->cy, &tmp_gu);
1126 gc->flags |= GRID_FLAG_UTF8;
1127 }
1128
1129 /* Append the current cell. */
1130 gu = grid_view_get_utf8(gd, s->cx - 1, s->cy);
1131 if (grid_utf8_append(gu, utf8data) != 0) {
1132 /* Failed: scrap this character and replace with underscores. */
1133 if (gu->width == 1) {
1134 gc->data = '_';
1135 gc->flags &= ~GRID_FLAG_UTF8;
1136 } else {
1137 for (i = 0; i < gu->width && i != sizeof gu->data; i++)
1138 gu->data[i] = '_';
1139 if (i != sizeof gu->data)
1140 gu->data[i] = 0xff;
1141 gu->width = i;
1142 }
1143 }
1144
1145 return (0);
1146 }
1147
1148 /*
1149 * UTF-8 wide characters are a bit of an annoyance. They take up more than one
1150 * cell on the screen, so following cells must not be drawn by marking them as
1151 * padding.
1152 *
1153 * So far, so good. The problem is, when overwriting a padding cell, or a UTF-8
1154 * character, it is necessary to also overwrite any other cells which covered
1155 * by the same character.
1156 */
1157 void
1158 screen_write_overwrite(struct screen_write_ctx *ctx, u_int width)
1159 {
1160 struct screen *s = ctx->s;
1161 struct grid *gd = s->grid;
1162 const struct grid_cell *gc;
1163 u_int xx;
1164
1165 gc = grid_view_peek_cell(gd, s->cx, s->cy);
1166 if (gc->flags & GRID_FLAG_PADDING) {
1167 /*
1168 * A padding cell, so clear any following and leading padding
1169 * cells back to the character. Don't overwrite the current
1170 * cell as that happens later anyway.
1171 */
1172 xx = s->cx + 1;
1173 while (--xx > 0) {
1174 gc = grid_view_peek_cell(gd, xx, s->cy);
1175 if (!(gc->flags & GRID_FLAG_PADDING))
1176 break;
1177 grid_view_set_cell(gd, xx, s->cy, &grid_default_cell);
1178 }
1179
1180 /* Overwrite the character at the start of this padding. */
1181 grid_view_set_cell(gd, xx, s->cy, &grid_default_cell);
1182 }
1183
1184 /*
1185 * Overwrite any padding cells that belong to a UTF-8 character
1186 * we'll be overwriting with the current character.
1187 */
1188 xx = s->cx + width - 1;
1189 while (++xx < screen_size_x(s)) {
1190 gc = grid_view_peek_cell(gd, xx, s->cy);
1191 if (!(gc->flags & GRID_FLAG_PADDING))
1192 break;
1193 grid_view_set_cell(gd, xx, s->cy, &grid_default_cell);
1194 }
1195 }
1196
1197 void
1198 screen_write_setselection(struct screen_write_ctx *ctx, u_char *str, u_int len)
1199 {
1200 struct tty_ctx ttyctx;
1201
1202 screen_write_initctx(ctx, &ttyctx, 0);
1203 ttyctx.ptr = str;
1204 ttyctx.num = len;
1205
1206 tty_write(tty_cmd_setselection, &ttyctx);
1207 }
1208
1209 void
1210 screen_write_rawstring(struct screen_write_ctx *ctx, u_char *str, u_int len)
1211 {
1212 struct tty_ctx ttyctx;
1213
1214 screen_write_initctx(ctx, &ttyctx, 0);
1215 ttyctx.ptr = str;
1216 ttyctx.num = len;
1217
1218 tty_write(tty_cmd_rawstring, &ttyctx);
1219 }