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