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