1 /*
2  * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <ctype.h>
18 #include <stdlib.h>
19 #include <string.h>
20 
21 #include "defaults.h"
22 #include "telescope.h"
23 #include "utf8.h"
24 
25 /*
26  * Text wrapping
27  * =============
28  *
29  * There's a simple text wrapping algorithm.
30  *
31  * 1. if it's a line in a pre-formatted block:
32  *    a. hard wrap.
33  *    b. repeat
34  * 2. otherwise advance the line char by char.
35  * 3. when ending the space, split the line at the last occurrence of
36  *    a "word separator" (i.e. " \t-") or at point if none.
37  * 4. repeat
38  *
39  */
40 
41 void
42 erase_buffer(struct buffer *buffer)
43 {
44 	empty_vlist(buffer);
45 	empty_linelist(buffer);
46 }
47 
48 void
49 empty_linelist(struct buffer *buffer)
50 {
51 	struct line *l, *lt;
52 
53 	TAILQ_FOREACH_SAFE(l, &buffer->page.head, lines, lt) {
54 		TAILQ_REMOVE(&buffer->page.head, l, lines);
55 		free(l->line);
56 
57 		if (l->type != LINE_COMPL &&
58 		    l->type != LINE_COMPL_CURRENT)
59 			free(l->alt);
60 
61 		free(l);
62 	}
63 }
64 
65 void
66 empty_vlist(struct buffer *buffer)
67 {
68 	struct vline *vl, *t;
69 
70 	buffer->top_line = NULL;
71 	buffer->line_off = 0;
72 	buffer->current_line = NULL;
73 	buffer->line_max = 0;
74 
75 	TAILQ_FOREACH_SAFE(vl, &buffer->head, vlines, t) {
76 		TAILQ_REMOVE(&buffer->head, vl, vlines);
77 		free(vl->line);
78 		free(vl);
79 	}
80 }
81 
82 static int
83 push_line(struct buffer *buffer, struct line *l, const char *buf, size_t len, int flags)
84 {
85 	struct vline *vl;
86 	const char *end;
87 
88 	/* omit trailing spaces */
89 	if (len != 0) {
90 		for (end = buf + len - 1;
91 		     end > buf && isspace(*end);
92 		     end--, len--)
93 			;	/* nop */
94 	}
95 
96 	if (!(l->flags & L_HIDDEN))
97 		buffer->line_max++;
98 
99 	if ((vl = calloc(1, sizeof(*vl))) == NULL)
100 		return 0;
101 
102 	if (len != 0 && (vl->line = calloc(1, len+1)) == NULL) {
103 		free(vl);
104 		return 0;
105 	}
106 
107 	vl->parent = l;
108 	if (len != 0)
109 		memcpy(vl->line, buf, len);
110 	vl->flags = flags;
111 
112 	if (TAILQ_EMPTY(&buffer->head))
113 		TAILQ_INSERT_HEAD(&buffer->head, vl, vlines);
114 	else
115 		TAILQ_INSERT_TAIL(&buffer->head, vl, vlines);
116 	return 1;
117 }
118 
119 /*
120  * Similar to wrap_text, but emit only o vline.
121  */
122 int
123 wrap_one(struct buffer *buffer, const char *prfx, struct line *l, size_t width)
124 {
125 	struct vline *vl, *t;
126 
127 	/*
128 	 * be lazy: call wrap_text and then discard the continuations.
129 	 */
130 
131 	if (!wrap_text(buffer, prfx, l, width))
132 		return 0;
133 
134 	TAILQ_FOREACH_SAFE(vl, &buffer->head, vlines, t) {
135 		if (vl->flags & L_CONTINUATION) {
136 			TAILQ_REMOVE(&buffer->head, vl, vlines);
137 			free(vl->line);
138 			free(vl);
139 			buffer->line_max--;
140 		}
141 	}
142 
143 	return 1;
144 }
145 
146 /*
147  * Build a list of visual line by wrapping the given line, assuming
148  * that when printed will have a leading prefix prfx.
149  */
150 int
151 wrap_text(struct buffer *buffer, const char *prfx, struct line *l, size_t width)
152 {
153 	const char	*separators = " \t-";
154 	const char	*start, *end, *line, *lastsep, *lastchar, *space;
155 	uint32_t	 cp = 0, state = 0;
156 	size_t		 cur, prfxwidth, w;
157 	int		 flags;
158 
159 	if ((line = l->line) == NULL)
160 		return push_line(buffer, l, NULL, 0, 0);
161 
162 	prfxwidth = utf8_swidth(prfx);
163 	cur = prfxwidth;
164 	start = line;
165 	lastsep = NULL;
166 	lastchar = line;
167 	flags = 0;
168 
169 	if (l->type == LINE_LINK && emojify_link &&
170 	    emojied_line(l->line, &space)) {
171 		prfxwidth = utf8_swidth_between(l->line, space);
172 		cur = prfxwidth;
173 		line = space + 1;
174 	}
175 
176 	for (; *line; line++) {
177 		if (utf8_decode(&state, &cp, *line))
178 			continue;
179 		w = utf8_chwidth(cp);
180 		if (cur + w > width) {
181 			end = lastsep == NULL
182 				? utf8_next_cp((char*)lastchar)
183 				: utf8_next_cp((char*)lastsep);
184 			if (!push_line(buffer, l, start, end - start, flags))
185 				return 0;
186 			flags = L_CONTINUATION;
187 			start = end;
188 			cur = prfxwidth + utf8_swidth_between(start, lastchar);
189 		} else if (strchr(separators, *line) != NULL) {
190 			lastsep = line;
191 		}
192 
193 		lastchar = utf8_prev_cp(line, l->line);
194 		cur += w;
195 	}
196 
197 	return push_line(buffer, l, start, line - start, flags);
198 }
199 
200 int
201 hardwrap_text(struct buffer *buffer, struct line *l, size_t width)
202 {
203 	const char	*line, *start, *lastchar;
204 	int		 cont;
205 	uint32_t	 state = 0, cp = 0;
206 	size_t		 cur, w;
207 
208 	if ((line = l->line) == NULL)
209 		return push_line(buffer, l, NULL, 0, 0);
210 
211 	start = line;
212 	lastchar = line;
213 	cont = 0;
214 	cur = 0;
215 	for (; *line; line++) {
216 		if (utf8_decode(&state, &cp, *line))
217 			continue;
218 		w = utf8_chwidth(cp);
219 		if (cur + w >= width) {
220 			if (!push_line(buffer, l, start, lastchar - start, cont))
221 				return 0;
222 			cont = L_CONTINUATION;
223 			if (dont_wrap_pre)
224                                 return 1;
225 			cur = 0;
226 			start = lastchar;
227 		}
228 
229 		lastchar = utf8_prev_cp(line, l->line);
230 		cur += w;
231 	}
232 
233 	return push_line(buffer, l, start, line - start, cont);
234 }