?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add two new values for the destroy-unattached option to destroy sessions
[tmux-openbsd.git] / format-draw.c
bloba42dfe1dccab135a27c0c82bb002ddb7a5c77bcc
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2019 Nicholas Marriott <nicholas.marriott@gmail.com>
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 /* Format range. */
27 struct format_range {
28 u_int index;
29 struct screen *s;
30
31 u_int start;
32 u_int end;
33
34 enum style_range_type type;
35 u_int argument;
36 char string[16];
37
38 TAILQ_ENTRY(format_range) entry;
39 };
40 TAILQ_HEAD(format_ranges, format_range);
41
42 /* Does this range match this style? */
43 static int
44 format_is_type(struct format_range *fr, struct style *sy)
45 {
46 if (fr->type != sy->range_type)
47 return (0);
48 switch (fr->type) {
49 case STYLE_RANGE_NONE:
50 case STYLE_RANGE_LEFT:
51 case STYLE_RANGE_RIGHT:
52 return (1);
53 case STYLE_RANGE_PANE:
54 case STYLE_RANGE_WINDOW:
55 case STYLE_RANGE_SESSION:
56 return (fr->argument == sy->range_argument);
57 case STYLE_RANGE_USER:
58 return (strcmp(fr->string, sy->range_string) == 0);
59 }
60 return (1);
61 }
62
63 /* Free a range. */
64 static void
65 format_free_range(struct format_ranges *frs, struct format_range *fr)
66 {
67 TAILQ_REMOVE(frs, fr, entry);
68 free(fr);
69 }
70
71 /* Fix range positions. */
72 static void
73 format_update_ranges(struct format_ranges *frs, struct screen *s, u_int offset,
74 u_int start, u_int width)
75 {
76 struct format_range *fr, *fr1;
77
78 if (frs == NULL)
79 return;
80
81 TAILQ_FOREACH_SAFE(fr, frs, entry, fr1) {
82 if (fr->s != s)
83 continue;
84
85 if (fr->end <= start || fr->start >= start + width) {
86 format_free_range(frs, fr);
87 continue;
88 }
89
90 if (fr->start < start)
91 fr->start = start;
92 if (fr->end > start + width)
93 fr->end = start + width;
94 if (fr->start == fr->end) {
95 format_free_range(frs, fr);
96 continue;
97 }
98
99 fr->start -= start;
100 fr->end -= start;
101
102 fr->start += offset;
103 fr->end += offset;
104 }
105 }
106
107 /* Draw a part of the format. */
108 static void
109 format_draw_put(struct screen_write_ctx *octx, u_int ocx, u_int ocy,
110 struct screen *s, struct format_ranges *frs, u_int offset, u_int start,
111 u_int width)
112 {
113 /*
114 * The offset is how far from the cursor on the target screen; start
115 * and width how much to copy from the source screen.
116 */
117 screen_write_cursormove(octx, ocx + offset, ocy, 0);
118 screen_write_fast_copy(octx, s, start, 0, width, 1);
119 format_update_ranges(frs, s, offset, start, width);
120 }
121
122 /* Draw list part of format. */
123 static void
124 format_draw_put_list(struct screen_write_ctx *octx,
125 u_int ocx, u_int ocy, u_int offset, u_int width, struct screen *list,
126 struct screen *list_left, struct screen *list_right, int focus_start,
127 int focus_end, struct format_ranges *frs)
128 {
129 u_int start, focus_centre;
130
131 /* If there is enough space for the list, draw it entirely. */
132 if (width >= list->cx) {
133 format_draw_put(octx, ocx, ocy, list, frs, offset, 0, width);
134 return;
135 }
136
137 /* The list needs to be trimmed. Try to keep the focus visible. */
138 focus_centre = focus_start + (focus_end - focus_start) / 2;
139 if (focus_centre < width / 2)
140 start = 0;
141 else
142 start = focus_centre - width / 2;
143 if (start + width > list->cx)
144 start = list->cx - width;
145
146 /* Draw <> markers at either side if needed. */
147 if (start != 0 && width > list_left->cx) {
148 screen_write_cursormove(octx, ocx + offset, ocy, 0);
149 screen_write_fast_copy(octx, list_left, 0, 0, list_left->cx, 1);
150 offset += list_left->cx;
151 start += list_left->cx;
152 width -= list_left->cx;
153 }
154 if (start + width < list->cx && width > list_right->cx) {
155 screen_write_cursormove(octx, ocx + offset + width -
156 list_right->cx, ocy, 0);
157 screen_write_fast_copy(octx, list_right, 0, 0, list_right->cx,
158 1);
159 width -= list_right->cx;
160 }
161
162 /* Draw the list screen itself. */
163 format_draw_put(octx, ocx, ocy, list, frs, offset, start, width);
164 }
165
166 /* Draw format with no list. */
167 static void
168 format_draw_none(struct screen_write_ctx *octx, u_int available, u_int ocx,
169 u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
170 struct screen *abs_centre, struct format_ranges *frs)
171 {
172 u_int width_left, width_centre, width_right, width_abs_centre;
173
174 width_left = left->cx;
175 width_centre = centre->cx;
176 width_right = right->cx;
177 width_abs_centre = abs_centre->cx;
178
179 /*
180 * Try to keep as much of the left and right as possible at the expense
181 * of the centre.
182 */
183 while (width_left + width_centre + width_right > available) {
184 if (width_centre > 0)
185 width_centre--;
186 else if (width_right > 0)
187 width_right--;
188 else
189 width_left--;
190 }
191
192 /* Write left. */
193 format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
194
195 /* Write right at available - width_right. */
196 format_draw_put(octx, ocx, ocy, right, frs,
197 available - width_right,
198 right->cx - width_right,
199 width_right);
200
201 /*
202 * Write centre halfway between
203 * width_left
204 * and
205 * available - width_right.
206 */
207 format_draw_put(octx, ocx, ocy, centre, frs,
208 width_left
209 + ((available - width_right) - width_left) / 2
210 - width_centre / 2,
211 centre->cx / 2 - width_centre / 2,
212 width_centre);
213
214 /*
215 * Write abs_centre in the perfect centre of all horizontal space.
216 */
217 if (width_abs_centre > available)
218 width_abs_centre = available;
219 format_draw_put(octx, ocx, ocy, abs_centre, frs,
220 (available - width_abs_centre) / 2,
221 0,
222 width_abs_centre);
223 }
224
225 /* Draw format with list on the left. */
226 static void
227 format_draw_left(struct screen_write_ctx *octx, u_int available, u_int ocx,
228 u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
229 struct screen *abs_centre, struct screen *list, struct screen *list_left,
230 struct screen *list_right, struct screen *after, int focus_start,
231 int focus_end, struct format_ranges *frs)
232 {
233 u_int width_left, width_centre, width_right;
234 u_int width_list, width_after, width_abs_centre;
235 struct screen_write_ctx ctx;
236
237 width_left = left->cx;
238 width_centre = centre->cx;
239 width_right = right->cx;
240 width_abs_centre = abs_centre->cx;
241 width_list = list->cx;
242 width_after = after->cx;
243
244 /*
245 * Trim first the centre, then the list, then the right, then after the
246 * list, then the left.
247 */
248 while (width_left +
249 width_centre +
250 width_right +
251 width_list +
252 width_after > available) {
253 if (width_centre > 0)
254 width_centre--;
255 else if (width_list > 0)
256 width_list--;
257 else if (width_right > 0)
258 width_right--;
259 else if (width_after > 0)
260 width_after--;
261 else
262 width_left--;
263 }
264
265 /* If there is no list left, pass off to the no list function. */
266 if (width_list == 0) {
267 screen_write_start(&ctx, left);
268 screen_write_fast_copy(&ctx, after, 0, 0, width_after, 1);
269 screen_write_stop(&ctx);
270
271 format_draw_none(octx, available, ocx, ocy, left, centre,
272 right, abs_centre, frs);
273 return;
274 }
275
276 /* Write left at 0. */
277 format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
278
279 /* Write right at available - width_right. */
280 format_draw_put(octx, ocx, ocy, right, frs,
281 available - width_right,
282 right->cx - width_right,
283 width_right);
284
285 /* Write after at width_left + width_list. */
286 format_draw_put(octx, ocx, ocy, after, frs,
287 width_left + width_list,
288 0,
289 width_after);
290
291 /*
292 * Write centre halfway between
293 * width_left + width_list + width_after
294 * and
295 * available - width_right.
296 */
297 format_draw_put(octx, ocx, ocy, centre, frs,
298 (width_left + width_list + width_after)
299 + ((available - width_right)
300 - (width_left + width_list + width_after)) / 2
301 - width_centre / 2,
302 centre->cx / 2 - width_centre / 2,
303 width_centre);
304
305 /*
306 * The list now goes from
307 * width_left
308 * to
309 * width_left + width_list.
310 * If there is no focus given, keep the left in focus.
311 */
312 if (focus_start == -1 || focus_end == -1)
313 focus_start = focus_end = 0;
314 format_draw_put_list(octx, ocx, ocy, width_left, width_list, list,
315 list_left, list_right, focus_start, focus_end, frs);
316
317 /*
318 * Write abs_centre in the perfect centre of all horizontal space.
319 */
320 if (width_abs_centre > available)
321 width_abs_centre = available;
322 format_draw_put(octx, ocx, ocy, abs_centre, frs,
323 (available - width_abs_centre) / 2,
324 0,
325 width_abs_centre);
326 }
327
328 /* Draw format with list in the centre. */
329 static void
330 format_draw_centre(struct screen_write_ctx *octx, u_int available, u_int ocx,
331 u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
332 struct screen *abs_centre, struct screen *list, struct screen *list_left,
333 struct screen *list_right, struct screen *after, int focus_start,
334 int focus_end, struct format_ranges *frs)
335 {
336 u_int width_left, width_centre, width_right, middle;
337 u_int width_list, width_after, width_abs_centre;
338 struct screen_write_ctx ctx;
339
340 width_left = left->cx;
341 width_centre = centre->cx;
342 width_right = right->cx;
343 width_abs_centre = abs_centre->cx;
344 width_list = list->cx;
345 width_after = after->cx;
346
347 /*
348 * Trim first the list, then after the list, then the centre, then the
349 * right, then the left.
350 */
351 while (width_left +
352 width_centre +
353 width_right +
354 width_list +
355 width_after > available) {
356 if (width_list > 0)
357 width_list--;
358 else if (width_after > 0)
359 width_after--;
360 else if (width_centre > 0)
361 width_centre--;
362 else if (width_right > 0)
363 width_right--;
364 else
365 width_left--;
366 }
367
368 /* If there is no list left, pass off to the no list function. */
369 if (width_list == 0) {
370 screen_write_start(&ctx, centre);
371 screen_write_fast_copy(&ctx, after, 0, 0, width_after, 1);
372 screen_write_stop(&ctx);
373
374 format_draw_none(octx, available, ocx, ocy, left, centre,
375 right, abs_centre, frs);
376 return;
377 }
378
379 /* Write left at 0. */
380 format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
381
382 /* Write right at available - width_right. */
383 format_draw_put(octx, ocx, ocy, right, frs,
384 available - width_right,
385 right->cx - width_right,
386 width_right);
387
388 /*
389 * All three centre sections are offset from the middle of the
390 * available space.
391 */
392 middle = (width_left + ((available - width_right) - width_left) / 2);
393
394 /*
395 * Write centre at
396 * middle - width_list / 2 - width_centre.
397 */
398 format_draw_put(octx, ocx, ocy, centre, frs,
399 middle - width_list / 2 - width_centre,
400 0,
401 width_centre);
402
403 /*
404 * Write after at
405 * middle - width_list / 2 + width_list
406 */
407 format_draw_put(octx, ocx, ocy, after, frs,
408 middle - width_list / 2 + width_list,
409 0,
410 width_after);
411
412 /*
413 * The list now goes from
414 * middle - width_list / 2
415 * to
416 * middle + width_list / 2
417 * If there is no focus given, keep the centre in focus.
418 */
419 if (focus_start == -1 || focus_end == -1)
420 focus_start = focus_end = list->cx / 2;
421 format_draw_put_list(octx, ocx, ocy, middle - width_list / 2,
422 width_list, list, list_left, list_right, focus_start, focus_end,
423 frs);
424
425 /*
426 * Write abs_centre in the perfect centre of all horizontal space.
427 */
428 if (width_abs_centre > available)
429 width_abs_centre = available;
430 format_draw_put(octx, ocx, ocy, abs_centre, frs,
431 (available - width_abs_centre) / 2,
432 0,
433 width_abs_centre);
434 }
435
436 /* Draw format with list on the right. */
437 static void
438 format_draw_right(struct screen_write_ctx *octx, u_int available, u_int ocx,
439 u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
440 struct screen *abs_centre, struct screen *list,
441 struct screen *list_left, struct screen *list_right, struct screen *after,
442 int focus_start, int focus_end, struct format_ranges *frs)
443 {
444 u_int width_left, width_centre, width_right;
445 u_int width_list, width_after, width_abs_centre;
446 struct screen_write_ctx ctx;
447
448 width_left = left->cx;
449 width_centre = centre->cx;
450 width_right = right->cx;
451 width_abs_centre = abs_centre->cx;
452 width_list = list->cx;
453 width_after = after->cx;
454
455 /*
456 * Trim first the centre, then the list, then the right, then
457 * after the list, then the left.
458 */
459 while (width_left +
460 width_centre +
461 width_right +
462 width_list +
463 width_after > available) {
464 if (width_centre > 0)
465 width_centre--;
466 else if (width_list > 0)
467 width_list--;
468 else if (width_right > 0)
469 width_right--;
470 else if (width_after > 0)
471 width_after--;
472 else
473 width_left--;
474 }
475
476 /* If there is no list left, pass off to the no list function. */
477 if (width_list == 0) {
478 screen_write_start(&ctx, right);
479 screen_write_fast_copy(&ctx, after, 0, 0, width_after, 1);
480 screen_write_stop(&ctx);
481
482 format_draw_none(octx, available, ocx, ocy, left, centre,
483 right, abs_centre, frs);
484 return;
485 }
486
487 /* Write left at 0. */
488 format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
489
490 /* Write after at available - width_after. */
491 format_draw_put(octx, ocx, ocy, after, frs,
492 available - width_after,
493 after->cx - width_after,
494 width_after);
495
496 /*
497 * Write right at
498 * available - width_right - width_list - width_after.
499 */
500 format_draw_put(octx, ocx, ocy, right, frs,
501 available - width_right - width_list - width_after,
502 0,
503 width_right);
504
505 /*
506 * Write centre halfway between
507 * width_left
508 * and
509 * available - width_right - width_list - width_after.
510 */
511 format_draw_put(octx, ocx, ocy, centre, frs,
512 width_left
513 + ((available - width_right - width_list - width_after)
514 - width_left) / 2
515 - width_centre / 2,
516 centre->cx / 2 - width_centre / 2,
517 width_centre);
518
519 /*
520 * The list now goes from
521 * available - width_list - width_after
522 * to
523 * available - width_after
524 * If there is no focus given, keep the right in focus.
525 */
526 if (focus_start == -1 || focus_end == -1)
527 focus_start = focus_end = 0;
528 format_draw_put_list(octx, ocx, ocy, available - width_list -
529 width_after, width_list, list, list_left, list_right, focus_start,
530 focus_end, frs);
531
532 /*
533 * Write abs_centre in the perfect centre of all horizontal space.
534 */
535 if (width_abs_centre > available)
536 width_abs_centre = available;
537 format_draw_put(octx, ocx, ocy, abs_centre, frs,
538 (available - width_abs_centre) / 2,
539 0,
540 width_abs_centre);
541 }
542
543 static void
544 format_draw_absolute_centre(struct screen_write_ctx *octx, u_int available,
545 u_int ocx, u_int ocy, struct screen *left, struct screen *centre,
546 struct screen *right, struct screen *abs_centre, struct screen *list,
547 struct screen *list_left, struct screen *list_right, struct screen *after,
548 int focus_start, int focus_end, struct format_ranges *frs)
549 {
550 u_int width_left, width_centre, width_right, width_abs_centre;
551 u_int width_list, width_after, middle, abs_centre_offset;
552
553 width_left = left->cx;
554 width_centre = centre->cx;
555 width_right = right->cx;
556 width_abs_centre = abs_centre->cx;
557 width_list = list->cx;
558 width_after = after->cx;
559
560 /*
561 * Trim first centre, then the right, then the left.
562 */
563 while (width_left +
564 width_centre +
565 width_right > available) {
566 if (width_centre > 0)
567 width_centre--;
568 else if (width_right > 0)
569 width_right--;
570 else
571 width_left--;
572 }
573
574 /*
575 * We trim list after and abs_centre independently, as we are drawing
576 * them over the rest. Trim first the list, then after the list, then
577 * abs_centre.
578 */
579 while (width_list + width_after + width_abs_centre > available) {
580 if (width_list > 0)
581 width_list--;
582 else if (width_after > 0)
583 width_after--;
584 else
585 width_abs_centre--;
586 }
587
588 /* Write left at 0. */
589 format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
590
591 /* Write right at available - width_right. */
592 format_draw_put(octx, ocx, ocy, right, frs,
593 available - width_right,
594 right->cx - width_right,
595 width_right);
596
597 /*
598 * Keep writing centre at the relative centre. Only the list is written
599 * in the absolute centre of the horizontal space.
600 */
601 middle = (width_left + ((available - width_right) - width_left) / 2);
602
603 /*
604 * Write centre at
605 * middle - width_centre.
606 */
607 format_draw_put(octx, ocx, ocy, centre, frs,
608 middle - width_centre,
609 0,
610 width_centre);
611
612 /*
613 * If there is no focus given, keep the centre in focus.
614 */
615 if (focus_start == -1 || focus_end == -1)
616 focus_start = focus_end = list->cx / 2;
617
618 /*
619 * We centre abs_centre and the list together, so their shared centre is
620 * in the perfect centre of horizontal space.
621 */
622 abs_centre_offset = (available - width_list - width_abs_centre) / 2;
623
624 /*
625 * Write abs_centre before the list.
626 */
627 format_draw_put(octx, ocx, ocy, abs_centre, frs, abs_centre_offset,
628 0, width_abs_centre);
629 abs_centre_offset += width_abs_centre;
630
631 /*
632 * Draw the list in the absolute centre
633 */
634 format_draw_put_list(octx, ocx, ocy, abs_centre_offset, width_list,
635 list, list_left, list_right, focus_start, focus_end, frs);
636 abs_centre_offset += width_list;
637
638 /*
639 * Write after at the end of the centre
640 */
641 format_draw_put(octx, ocx, ocy, after, frs, abs_centre_offset, 0,
642 width_after);
643 }
644
645 /* Get width and count of any leading #s. */
646 static const char *
647 format_leading_hashes(const char *cp, u_int *n, u_int *width)
648 {
649 for (*n = 0; cp[*n] == '#'; (*n)++)
650 /* nothing */;
651 if (*n == 0) {
652 *width = 0;
653 return (cp);
654 }
655 if (cp[*n] != '[') {
656 if ((*n % 2) == 0)
657 *width = (*n / 2);
658 else
659 *width = (*n / 2) + 1;
660 return (cp + *n);
661 }
662 *width = (*n / 2);
663 if ((*n % 2) == 0) {
664 /*
665 * An even number of #s means that all #s are escaped, so not a
666 * style. The caller should not skip this. Return pointing to
667 * the [.
668 */
669 return (cp + *n);
670 }
671 /* This is a style, so return pointing to the #. */
672 return (cp + *n - 1);
673 }
674
675 /* Draw multiple characters. */
676 static void
677 format_draw_many(struct screen_write_ctx *ctx, struct style *sy, char ch,
678 u_int n)
679 {
680 u_int i;
681
682 utf8_set(&sy->gc.data, ch);
683 for (i = 0; i < n; i++)
684 screen_write_cell(ctx, &sy->gc);
685 }
686
687 /* Draw a format to a screen. */
688 void
689 format_draw(struct screen_write_ctx *octx, const struct grid_cell *base,
690 u_int available, const char *expanded, struct style_ranges *srs,
691 int default_colours)
692 {
693 enum { LEFT,
694 CENTRE,
695 RIGHT,
696 ABSOLUTE_CENTRE,
697 LIST,
698 LIST_LEFT,
699 LIST_RIGHT,
700 AFTER,
701 TOTAL } current = LEFT, last = LEFT;
702 const char *names[] = { "LEFT",
703 "CENTRE",
704 "RIGHT",
705 "ABSOLUTE_CENTRE",
706 "LIST",
707 "LIST_LEFT",
708 "LIST_RIGHT",
709 "AFTER" };
710 size_t size = strlen(expanded);
711 struct screen *os = octx->s, s[TOTAL];
712 struct screen_write_ctx ctx[TOTAL];
713 u_int ocx = os->cx, ocy = os->cy, n, i, width[TOTAL];
714 u_int map[] = { LEFT,
715 LEFT,
716 CENTRE,
717 RIGHT,
718 ABSOLUTE_CENTRE };
719 int focus_start = -1, focus_end = -1;
720 int list_state = -1, fill = -1, even;
721 enum style_align list_align = STYLE_ALIGN_DEFAULT;
722 struct grid_cell gc, current_default;
723 struct style sy, saved_sy;
724 struct utf8_data *ud = &sy.gc.data;
725 const char *cp, *end;
726 enum utf8_state more;
727 char *tmp;
728 struct format_range *fr = NULL, *fr1;
729 struct format_ranges frs;
730 struct style_range *sr;
731
732 memcpy(&current_default, base, sizeof current_default);
733 style_set(&sy, &current_default);
734 TAILQ_INIT(&frs);
735 log_debug("%s: %s", __func__, expanded);
736
737 /*
738 * We build three screens for left, right, centre alignment, one for
739 * the list, one for anything after the list and two for the list left
740 * and right markers.
741 */
742 for (i = 0; i < TOTAL; i++) {
743 screen_init(&s[i], size, 1, 0);
744 screen_write_start(&ctx[i], &s[i]);
745 screen_write_clearendofline(&ctx[i], current_default.bg);
746 width[i] = 0;
747 }
748
749 /*
750 * Walk the string and add to the corresponding screens,
751 * parsing styles as we go.
752 */
753 cp = expanded;
754 while (*cp != '\0') {
755 /* Handle sequences of #. */
756 if (cp[0] == '#' && cp[1] != '[' && cp[1] != '\0') {
757 for (n = 1; cp[n] == '#'; n++)
758 /* nothing */;
759 even = ((n % 2) == 0);
760 if (cp[n] != '[') {
761 cp += n;
762 if (even)
763 n = (n / 2);
764 else
765 n = (n / 2) + 1;
766 width[current] += n;
767 format_draw_many(&ctx[current], &sy, '#', n);
768 continue;
769 }
770 if (even)
771 cp += (n + 1);
772 else
773 cp += (n - 1);
774 if (sy.ignore)
775 continue;
776 format_draw_many(&ctx[current], &sy, '#', n / 2);
777 width[current] += (n / 2);
778 if (even) {
779 utf8_set(ud, '[');
780 screen_write_cell(&ctx[current], &sy.gc);
781 width[current]++;
782 }
783 continue;
784 }
785
786 /* Is this not a style? */
787 if (cp[0] != '#' || cp[1] != '[' || sy.ignore) {
788 /* See if this is a UTF-8 character. */
789 if ((more = utf8_open(ud, *cp)) == UTF8_MORE) {
790 while (*++cp != '\0' && more == UTF8_MORE)
791 more = utf8_append(ud, *cp);
792 if (more != UTF8_DONE)
793 cp -= ud->have;
794 }
795
796 /* Not a UTF-8 character - ASCII or not valid. */
797 if (more != UTF8_DONE) {
798 if (*cp < 0x20 || *cp > 0x7e) {
799 /* Ignore nonprintable characters. */
800 cp++;
801 continue;
802 }
803 utf8_set(ud, *cp);
804 cp++;
805 }
806
807 /* Draw the cell to the current screen. */
808 screen_write_cell(&ctx[current], &sy.gc);
809 width[current] += ud->width;
810 continue;
811 }
812
813 /* This is a style. Work out where the end is and parse it. */
814 end = format_skip(cp + 2, "]");
815 if (end == NULL) {
816 log_debug("%s: no terminating ] at '%s'", __func__,
817 cp + 2);
818 TAILQ_FOREACH_SAFE(fr, &frs, entry, fr1)
819 format_free_range(&frs, fr);
820 goto out;
821 }
822 tmp = xstrndup(cp + 2, end - (cp + 2));
823 style_copy(&saved_sy, &sy);
824 if (style_parse(&sy, &current_default, tmp) != 0) {
825 log_debug("%s: invalid style '%s'", __func__, tmp);
826 free(tmp);
827 cp = end + 1;
828 continue;
829 }
830 log_debug("%s: style '%s' -> '%s'", __func__, tmp,
831 style_tostring(&sy));
832 free(tmp);
833 if (default_colours) {
834 sy.gc.bg = base->bg;
835 sy.gc.fg = base->fg;
836 }
837
838 /* If this style has a fill colour, store it for later. */
839 if (sy.fill != 8)
840 fill = sy.fill;
841
842 /* If this style pushed or popped the default, update it. */
843 if (sy.default_type == STYLE_DEFAULT_PUSH) {
844 memcpy(&current_default, &saved_sy.gc,
845 sizeof current_default);
846 sy.default_type = STYLE_DEFAULT_BASE;
847 } else if (sy.default_type == STYLE_DEFAULT_POP) {
848 memcpy(&current_default, base, sizeof current_default);
849 sy.default_type = STYLE_DEFAULT_BASE;
850 }
851
852 /* Check the list state. */
853 switch (sy.list) {
854 case STYLE_LIST_ON:
855 /*
856 * Entering the list, exiting a marker, or exiting the
857 * focus.
858 */
859 if (list_state != 0) {
860 if (fr != NULL) { /* abort any region */
861 free(fr);
862 fr = NULL;
863 }
864 list_state = 0;
865 list_align = sy.align;
866 }
867
868 /* End the focus if started. */
869 if (focus_start != -1 && focus_end == -1)
870 focus_end = s[LIST].cx;
871
872 current = LIST;
873 break;
874 case STYLE_LIST_FOCUS:
875 /* Entering the focus. */
876 if (list_state != 0) /* not inside the list */
877 break;
878 if (focus_start == -1) /* focus already started */
879 focus_start = s[LIST].cx;
880 break;
881 case STYLE_LIST_OFF:
882 /* Exiting or outside the list. */
883 if (list_state == 0) {
884 if (fr != NULL) { /* abort any region */
885 free(fr);
886 fr = NULL;
887 }
888 if (focus_start != -1 && focus_end == -1)
889 focus_end = s[LIST].cx;
890
891 map[list_align] = AFTER;
892 if (list_align == STYLE_ALIGN_LEFT)
893 map[STYLE_ALIGN_DEFAULT] = AFTER;
894 list_state = 1;
895 }
896 current = map[sy.align];
897 break;
898 case STYLE_LIST_LEFT_MARKER:
899 /* Entering left marker. */
900 if (list_state != 0) /* not inside the list */
901 break;
902 if (s[LIST_LEFT].cx != 0) /* already have marker */
903 break;
904 if (fr != NULL) { /* abort any region */
905 free(fr);
906 fr = NULL;
907 }
908 if (focus_start != -1 && focus_end == -1)
909 focus_start = focus_end = -1;
910 current = LIST_LEFT;
911 break;
912 case STYLE_LIST_RIGHT_MARKER:
913 /* Entering right marker. */
914 if (list_state != 0) /* not inside the list */
915 break;
916 if (s[LIST_RIGHT].cx != 0) /* already have marker */
917 break;
918 if (fr != NULL) { /* abort any region */
919 free(fr);
920 fr = NULL;
921 }
922 if (focus_start != -1 && focus_end == -1)
923 focus_start = focus_end = -1;
924 current = LIST_RIGHT;
925 break;
926 }
927 if (current != last) {
928 log_debug("%s: change %s -> %s", __func__,
929 names[last], names[current]);
930 last = current;
931 }
932
933 /*
934 * Check if the range style has changed and if so end the
935 * current range and start a new one if needed.
936 */
937 if (srs != NULL) {
938 if (fr != NULL && !format_is_type(fr, &sy)) {
939 if (s[current].cx != fr->start) {
940 fr->end = s[current].cx + 1;
941 TAILQ_INSERT_TAIL(&frs, fr, entry);
942 } else
943 free(fr);
944 fr = NULL;
945 }
946 if (fr == NULL && sy.range_type != STYLE_RANGE_NONE) {
947 fr = xcalloc(1, sizeof *fr);
948 fr->index = current;
949
950 fr->s = &s[current];
951 fr->start = s[current].cx;
952
953 fr->type = sy.range_type;
954 fr->argument = sy.range_argument;
955 strlcpy(fr->string, sy.range_string,
956 sizeof fr->string);
957 }
958 }
959
960 cp = end + 1;
961 }
962 free(fr);
963
964 for (i = 0; i < TOTAL; i++) {
965 screen_write_stop(&ctx[i]);
966 log_debug("%s: width %s is %u", __func__, names[i], width[i]);
967 }
968 if (focus_start != -1 && focus_end != -1)
969 log_debug("%s: focus %d-%d", __func__, focus_start, focus_end);
970 TAILQ_FOREACH(fr, &frs, entry) {
971 log_debug("%s: range %d|%u is %s %u-%u", __func__, fr->type,
972 fr->argument, names[fr->index], fr->start, fr->end);
973 }
974
975 /* Clear the available area. */
976 if (fill != -1) {
977 memcpy(&gc, &grid_default_cell, sizeof gc);
978 gc.bg = fill;
979 for (i = 0; i < available; i++)
980 screen_write_putc(octx, &gc, ' ');
981 }
982
983 /*
984 * Draw the screens. How they are arranged depends on where the list
985 * appears.
986 */
987 switch (list_align) {
988 case STYLE_ALIGN_DEFAULT:
989 /* No list. */
990 format_draw_none(octx, available, ocx, ocy, &s[LEFT],
991 &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &frs);
992 break;
993 case STYLE_ALIGN_LEFT:
994 /* List is part of the left. */
995 format_draw_left(octx, available, ocx, ocy, &s[LEFT],
996 &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &s[LIST],
997 &s[LIST_LEFT], &s[LIST_RIGHT], &s[AFTER],
998 focus_start, focus_end, &frs);
999 break;
1000 case STYLE_ALIGN_CENTRE:
1001 /* List is part of the centre. */
1002 format_draw_centre(octx, available, ocx, ocy, &s[LEFT],
1003 &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &s[LIST],
1004 &s[LIST_LEFT], &s[LIST_RIGHT], &s[AFTER],
1005 focus_start, focus_end, &frs);
1006 break;
1007 case STYLE_ALIGN_RIGHT:
1008 /* List is part of the right. */
1009 format_draw_right(octx, available, ocx, ocy, &s[LEFT],
1010 &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &s[LIST],
1011 &s[LIST_LEFT], &s[LIST_RIGHT], &s[AFTER],
1012 focus_start, focus_end, &frs);
1013 break;
1014 case STYLE_ALIGN_ABSOLUTE_CENTRE:
1015 /* List is in the centre of the entire horizontal space. */
1016 format_draw_absolute_centre(octx, available, ocx, ocy, &s[LEFT],
1017 &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &s[LIST],
1018 &s[LIST_LEFT], &s[LIST_RIGHT], &s[AFTER],
1019 focus_start, focus_end, &frs);
1020 break;
1021 }
1022
1023 /* Create ranges to return. */
1024 TAILQ_FOREACH_SAFE(fr, &frs, entry, fr1) {
1025 sr = xcalloc(1, sizeof *sr);
1026 sr->type = fr->type;
1027 sr->argument = fr->argument;
1028 strlcpy(sr->string, fr->string, sizeof sr->string);
1029 sr->start = fr->start;
1030 sr->end = fr->end;
1031 TAILQ_INSERT_TAIL(srs, sr, entry);
1032
1033 switch (sr->type) {
1034 case STYLE_RANGE_NONE:
1035 break;
1036 case STYLE_RANGE_LEFT:
1037 log_debug("%s: range left at %u-%u", __func__,
1038 sr->start, sr->end);
1039 break;
1040 case STYLE_RANGE_RIGHT:
1041 log_debug("%s: range right at %u-%u", __func__,
1042 sr->start, sr->end);
1043 break;
1044 case STYLE_RANGE_PANE:
1045 log_debug("%s: range pane|%%%u at %u-%u", __func__,
1046 sr->argument, sr->start, sr->end);
1047 break;
1048 case STYLE_RANGE_WINDOW:
1049 log_debug("%s: range window|%u at %u-%u", __func__,
1050 sr->argument, sr->start, sr->end);
1051 break;
1052 case STYLE_RANGE_SESSION:
1053 log_debug("%s: range session|$%u at %u-%u", __func__,
1054 sr->argument, sr->start, sr->end);
1055 break;
1056 case STYLE_RANGE_USER:
1057 log_debug("%s: range user|%u at %u-%u", __func__,
1058 sr->argument, sr->start, sr->end);
1059 break;
1060 }
1061 format_free_range(&frs, fr);
1062 }
1063
1064 out:
1065 /* Free the screens. */
1066 for (i = 0; i < TOTAL; i++)
1067 screen_free(&s[i]);
1068
1069 /* Restore the original cursor position. */
1070 screen_write_cursormove(octx, ocx, ocy, 0);
1071 }
1072
1073 /* Get width, taking #[] into account. */
1074 u_int
1075 format_width(const char *expanded)
1076 {
1077 const char *cp, *end;
1078 u_int n, leading_width, width = 0;
1079 struct utf8_data ud;
1080 enum utf8_state more;
1081
1082 cp = expanded;
1083 while (*cp != '\0') {
1084 if (*cp == '#') {
1085 end = format_leading_hashes(cp, &n, &leading_width);
1086 width += leading_width;
1087 cp = end;
1088 if (*cp == '#') {
1089 end = format_skip(cp + 2, "]");
1090 if (end == NULL)
1091 return (0);
1092 cp = end + 1;
1093 }
1094 } else if ((more = utf8_open(&ud, *cp)) == UTF8_MORE) {
1095 while (*++cp != '\0' && more == UTF8_MORE)
1096 more = utf8_append(&ud, *cp);
1097 if (more == UTF8_DONE)
1098 width += ud.width;
1099 else
1100 cp -= ud.have;
1101 } else if (*cp > 0x1f && *cp < 0x7f) {
1102 width++;
1103 cp++;
1104 } else
1105 cp++;
1106 }
1107 return (width);
1108 }
1109
1110 /*
1111 * Trim on the left, taking #[] into account. Note, we copy the whole set of
1112 * unescaped #s, but only add their escaped size to width. This is because the
1113 * format_draw function will actually do the escaping when it runs
1114 */
1115 char *
1116 format_trim_left(const char *expanded, u_int limit)
1117 {
1118 char *copy, *out;
1119 const char *cp = expanded, *end;
1120 u_int n, width = 0, leading_width;
1121 struct utf8_data ud;
1122 enum utf8_state more;
1123
1124 out = copy = xcalloc(2, strlen(expanded) + 1);
1125 while (*cp != '\0') {
1126 if (width >= limit)
1127 break;
1128 if (*cp == '#') {
1129 end = format_leading_hashes(cp, &n, &leading_width);
1130 if (leading_width > limit - width)
1131 leading_width = limit - width;
1132 if (leading_width != 0) {
1133 if (n == 1)
1134 *out++ = '#';
1135 else {
1136 memset(out, '#', 2 * leading_width);
1137 out += 2 * leading_width;
1138 }
1139 width += leading_width;
1140 }
1141 cp = end;
1142 if (*cp == '#') {
1143 end = format_skip(cp + 2, "]");
1144 if (end == NULL)
1145 break;
1146 memcpy(out, cp, end + 1 - cp);
1147 out += (end + 1 - cp);
1148 cp = end + 1;
1149 }
1150 } else if ((more = utf8_open(&ud, *cp)) == UTF8_MORE) {
1151 while (*++cp != '\0' && more == UTF8_MORE)
1152 more = utf8_append(&ud, *cp);
1153 if (more == UTF8_DONE) {
1154 if (width + ud.width <= limit) {
1155 memcpy(out, ud.data, ud.size);
1156 out += ud.size;
1157 }
1158 width += ud.width;
1159 } else {
1160 cp -= ud.have;
1161 cp++;
1162 }
1163 } else if (*cp > 0x1f && *cp < 0x7f) {
1164 if (width + 1 <= limit)
1165 *out++ = *cp;
1166 width++;
1167 cp++;
1168 } else
1169 cp++;
1170 }
1171 *out = '\0';
1172 return (copy);
1173 }
1174
1175 /* Trim on the right, taking #[] into account. */
1176 char *
1177 format_trim_right(const char *expanded, u_int limit)
1178 {
1179 char *copy, *out;
1180 const char *cp = expanded, *end;
1181 u_int width = 0, total_width, skip, n;
1182 u_int leading_width, copy_width;
1183 struct utf8_data ud;
1184 enum utf8_state more;
1185
1186 total_width = format_width(expanded);
1187 if (total_width <= limit)
1188 return (xstrdup(expanded));
1189 skip = total_width - limit;
1190
1191 out = copy = xcalloc(2, strlen(expanded) + 1);
1192 while (*cp != '\0') {
1193 if (*cp == '#') {
1194 end = format_leading_hashes(cp, &n, &leading_width);
1195 copy_width = leading_width;
1196 if (width <= skip) {
1197 if (skip - width >= copy_width)
1198 copy_width = 0;
1199 else
1200 copy_width -= (skip - width);
1201 }
1202 if (copy_width != 0) {
1203 if (n == 1)
1204 *out++ = '#';
1205 else {
1206 memset(out, '#', 2 * copy_width);
1207 out += 2 * copy_width;
1208 }
1209 }
1210 width += leading_width;
1211 cp = end;
1212 if (*cp == '#') {
1213 end = format_skip(cp + 2, "]");
1214 if (end == NULL)
1215 break;
1216 memcpy(out, cp, end + 1 - cp);
1217 out += (end + 1 - cp);
1218 cp = end + 1;
1219 }
1220 } else if ((more = utf8_open(&ud, *cp)) == UTF8_MORE) {
1221 while (*++cp != '\0' && more == UTF8_MORE)
1222 more = utf8_append(&ud, *cp);
1223 if (more == UTF8_DONE) {
1224 if (width >= skip) {
1225 memcpy(out, ud.data, ud.size);
1226 out += ud.size;
1227 }
1228 width += ud.width;
1229 } else {
1230 cp -= ud.have;
1231 cp++;
1232 }
1233 } else if (*cp > 0x1f && *cp < 0x7f) {
1234 if (width >= skip)
1235 *out++ = *cp;
1236 width++;
1237 cp++;
1238 } else
1239 cp++;
1240 }
1241 *out = '\0';
1242 return (copy);
1243 }