2 * Copyright (c) 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
7 * See the LICENSE file for redistribution information.
12 #include <sys/types.h>
13 #include <sys/queue.h>
16 #include <bitstring.h>
21 #include "../common/common.h"
24 #ifdef VISIBLE_TAB_CHARS
32 * Update one line on the screen.
34 * PUBLIC: int vs_line(SCR *, SMAP *, size_t *, size_t *);
37 vs_line(SCR
*sp
, SMAP
*smp
, size_t *yp
, size_t *xp
)
42 size_t chlen
= 0, cno_cnt
, cols_per_screen
, len
, nlen
;
43 size_t offset_in_char
, offset_in_line
, oldx
, oldy
;
44 size_t scno
, skip_cols
, skip_screens
;
45 int dne
, is_cached
, is_partial
, is_tab
, no_draw
;
46 int list_tab
, list_dollar
;
48 CHAR_T
*cbp
, *ecbp
, cbuf
[128];
51 #if defined(DEBUG) && 0
52 TRACE(sp
, "vs_line: row %u: line: %u off: %u\n",
53 smp
- HMAP
, smp
->lno
, smp
->off
);
56 * If ex modifies the screen after ex output is already on the screen,
57 * don't touch it -- we'll get scrolling wrong, at best.
60 if (!F_ISSET(sp
, SC_TINPUT_INFO
) && VIP(sp
)->totalcount
> 1)
62 if (F_ISSET(sp
, SC_SCR_EXWROTE
) && smp
- HMAP
!= LASTLINE(sp
))
66 * Assume that, if the cache entry for the line is filled in, the
67 * line is already on the screen, and all we need to do is return
68 * the cursor position. If the calling routine doesn't need the
69 * cursor position, we can just return.
71 is_cached
= SMAP_CACHE(smp
);
72 if (yp
== NULL
&& (is_cached
|| no_draw
))
76 * A nasty side effect of this routine is that it returns the screen
77 * position for the "current" character. Not pretty, but this is the
78 * only routine that really knows what's out there.
80 * Move to the line. This routine can be called by vs_sm_position(),
81 * which uses it to fill in the cache entry so it can figure out what
82 * the real contents of the screen are. Because of this, we have to
83 * return to whereever we started from.
86 (void)gp
->scr_cursor(sp
, &oldy
, &oldx
);
87 (void)gp
->scr_move(sp
, smp
- HMAP
, 0);
90 dne
= db_get(sp
, smp
->lno
, 0, &p
, &len
);
93 * Special case if we're printing the info/mode line. Skip printing
94 * the leading number, as well as other minor setup. The only time
95 * this code paints the mode line is when the user is entering text
96 * for a ":" command, so we can put the code here instead of dealing
97 * with the empty line logic below. This is a kludge, but it's pretty
98 * much confined to this module.
100 * Set the number of columns for this screen.
101 * Set the number of chars or screens to skip until a character is to
104 cols_per_screen
= sp
->cols
;
105 if (O_ISSET(sp
, O_LEFTRIGHT
)) {
107 skip_cols
= smp
->coff
;
109 skip_screens
= smp
->soff
- 1;
110 skip_cols
= skip_screens
* cols_per_screen
;
113 list_tab
= O_ISSET(sp
, O_LIST
);
114 if (F_ISSET(sp
, SC_TINPUT_INFO
))
117 list_dollar
= list_tab
;
120 * If O_NUMBER is set, the line doesn't exist and it's line
121 * number 1, i.e., an empty file, display the line number.
123 * If O_NUMBER is set, the line exists and the first character
124 * on the screen is the first character in the line, display
128 * If O_NUMBER set, decrement the number of columns in the
129 * first screen. DO NOT CHANGE THIS -- IT'S RIGHT! The
130 * rest of the code expects this to reflect the number of
131 * columns in the first screen, regardless of the number of
132 * columns we're going to skip.
134 if (O_ISSET(sp
, O_NUMBER
)) {
135 cols_per_screen
-= O_NUMBER_LENGTH
;
136 if ((!dne
|| smp
->lno
== 1) && skip_cols
== 0) {
137 nlen
= snprintf((char*)cbuf
,
138 sizeof(cbuf
), O_NUMBER_FMT
, (u_long
)smp
->lno
);
139 (void)gp
->scr_addstr(sp
, (char*)cbuf
, nlen
);
145 * Special case non-existent lines and the first line of an empty
146 * file. In both cases, the cursor position is 0, but corrected
147 * as necessary for the O_NUMBER field, if it was displayed.
149 if (dne
|| len
== 0) {
150 /* Fill in the cursor. */
151 if (yp
!= NULL
&& smp
->lno
== sp
->lno
) {
153 *xp
= sp
->cols
- cols_per_screen
;
156 /* If the line is on the screen, quit. */
157 if (is_cached
|| no_draw
)
160 /* Set line cache information. */
161 smp
->c_sboff
= smp
->c_eboff
= 0;
162 smp
->c_scoff
= smp
->c_eclen
= 0;
165 * Lots of special cases for empty lines, but they only apply
166 * if we're displaying the first screen of the line.
182 empty
: (void)gp
->scr_addstr(sp
,
183 KEY_NAME(sp
, ch
), KEY_LEN(sp
, ch
));
186 (void)gp
->scr_clrtoeol(sp
);
187 (void)gp
->scr_move(sp
, oldy
, oldx
);
191 /* If we shortened this line in another screen, the cursor
192 * position may have fallen off.
194 if (sp
->lno
== smp
->lno
&& sp
->cno
>= len
)
198 * If we just wrote this or a previous line, we cached the starting
199 * and ending positions of that line. The way it works is we keep
200 * information about the lines displayed in the SMAP. If we're
201 * painting the screen in the forward direction, this saves us from
202 * reformatting the physical line for every line on the screen. This
203 * wins big on binary files with 10K lines.
205 * Test for the first screen of the line, then the current screen line,
206 * then the line behind us, then do the hard work. Note, it doesn't
207 * do us any good to have a line in front of us -- it would be really
208 * hard to try and figure out tabs in the reverse direction, i.e. how
209 * many spaces a tab takes up in the reverse direction depends on
210 * what characters preceded it.
212 * Test for the first screen of the line.
214 if (skip_cols
== 0) {
215 smp
->c_sboff
= offset_in_line
= 0;
216 smp
->c_scoff
= offset_in_char
= 0;
217 p
= &p
[offset_in_line
];
221 /* Test to see if we've seen this exact line before. */
223 offset_in_line
= smp
->c_sboff
;
224 offset_in_char
= smp
->c_scoff
;
225 p
= &p
[offset_in_line
];
227 /* Set cols_per_screen to 2nd and later line length. */
228 if (O_ISSET(sp
, O_LEFTRIGHT
) || skip_cols
> cols_per_screen
)
229 cols_per_screen
= sp
->cols
;
233 /* Test to see if we saw an earlier part of this line before. */
235 SMAP_CACHE(tsmp
= smp
- 1) && tsmp
->lno
== smp
->lno
) {
236 if (tsmp
->c_eclen
!= tsmp
->c_ecsize
) {
237 offset_in_line
= tsmp
->c_eboff
;
238 offset_in_char
= tsmp
->c_eclen
;
240 offset_in_line
= tsmp
->c_eboff
+ 1;
244 /* Put starting info for this line in the cache. */
245 smp
->c_sboff
= offset_in_line
;
246 smp
->c_scoff
= offset_in_char
;
247 p
= &p
[offset_in_line
];
249 /* Set cols_per_screen to 2nd and later line length. */
250 if (O_ISSET(sp
, O_LEFTRIGHT
) || skip_cols
> cols_per_screen
)
251 cols_per_screen
= sp
->cols
;
259 /* Do it the hard way, for leftright scrolling screens. */
260 if (O_ISSET(sp
, O_LEFTRIGHT
)) {
261 for (; offset_in_line
< len
; ++offset_in_line
) {
262 chlen
= (ch
= *p
++) == '\t' && !list_tab
?
263 TAB_OFF(scno
) : KEY_COL(sp
, ch
);
264 if ((scno
+= chlen
) >= skip_cols
)
268 /* Set cols_per_screen to 2nd and later line length. */
269 cols_per_screen
= sp
->cols
;
271 /* Put starting info for this line in the cache. */
272 if (offset_in_line
>= len
) {
273 smp
->c_sboff
= offset_in_line
;
275 } else if (scno
!= skip_cols
) {
276 smp
->c_sboff
= offset_in_line
;
278 offset_in_char
= chlen
- (scno
- skip_cols
);
281 smp
->c_sboff
= ++offset_in_line
;
286 /* Do it the hard way, for historic line-folding screens. */
288 for (; offset_in_line
< len
; ++offset_in_line
) {
289 chlen
= (ch
= *p
++) == '\t' && !list_tab
?
290 TAB_OFF(scno
) : KEY_COL(sp
, ch
);
291 if ((scno
+= chlen
) < cols_per_screen
)
293 scno
-= cols_per_screen
;
295 /* Set cols_per_screen to 2nd and later line length. */
296 cols_per_screen
= sp
->cols
;
299 * If crossed the last skipped screen boundary, start
300 * displaying the characters.
302 if (--skip_screens
== 0)
306 /* Put starting info for this line in the cache. */
308 smp
->c_sboff
= offset_in_line
;
309 smp
->c_scoff
= offset_in_char
= chlen
- scno
;
312 smp
->c_sboff
= ++offset_in_line
;
319 * Set the number of characters to skip before reaching the cursor
320 * character. Offset by 1 and use 0 as a flag value. Vs_line is
321 * called repeatedly with a valid pointer to a cursor position.
322 * Don't fill anything in unless it's the right line and the right
323 * character, and the right part of the character...
326 smp
->lno
!= sp
->lno
|| sp
->cno
< offset_in_line
||
327 offset_in_line
+ cols_per_screen
< sp
->cno
) {
329 /* If the line is on the screen, quit. */
330 if (is_cached
|| no_draw
)
333 cno_cnt
= (sp
->cno
- offset_in_line
) + 1;
335 /* This is the loop that actually displays characters. */
336 ecbp
= (cbp
= cbuf
) + SIZE(cbuf
) - 1;
337 for (is_partial
= 0, scno
= 0;
338 offset_in_line
< len
; ++offset_in_line
, offset_in_char
= 0) {
339 if ((ch
= *p
++) == '\t' && !list_tab
) {
340 scno
+= chlen
= TAB_OFF(scno
) - offset_in_char
;
343 scno
+= chlen
= KEY_COL(sp
, ch
) - offset_in_char
;
348 * Only display up to the right-hand column. Set a flag if
349 * the entire character wasn't displayed for use in setting
350 * the cursor. If reached the end of the line, set the cache
351 * info for the screen. Don't worry about there not being
352 * characters to display on the next screen, its lno/off won't
353 * match up in that case.
355 if (scno
>= cols_per_screen
) {
357 chlen
-= scno
- cols_per_screen
;
358 smp
->c_ecsize
= smp
->c_eclen
= chlen
;
359 scno
= cols_per_screen
;
361 smp
->c_ecsize
= chlen
;
362 chlen
-= scno
- cols_per_screen
;
363 smp
->c_eclen
= chlen
;
365 if (scno
> cols_per_screen
)
368 smp
->c_eboff
= offset_in_line
;
370 /* Terminate the loop. */
371 offset_in_line
= len
;
375 * If the caller wants the cursor value, and this was the
376 * cursor character, set the value. There are two ways to
377 * put the cursor on a character -- if it's normal display
378 * mode, it goes on the last column of the character. If
379 * it's input mode, it goes on the first. In normal mode,
380 * set the cursor only if the entire character was displayed.
383 --cno_cnt
== 0 && (F_ISSET(sp
, SC_TINPUT
) || !is_partial
)) {
385 if (F_ISSET(sp
, SC_TINPUT
))
387 *xp
= scno
- smp
->c_ecsize
;
392 if (O_ISSET(sp
, O_NUMBER
) &&
393 !F_ISSET(sp
, SC_TINPUT_INFO
) && skip_cols
== 0)
394 *xp
+= O_NUMBER_LENGTH
;
396 /* If the line is on the screen, quit. */
397 if (is_cached
|| no_draw
)
401 /* If the line is on the screen, don't display anything. */
402 if (is_cached
|| no_draw
)
407 (void)gp->scr_waddstr(sp, cbuf, cbp - cbuf); \
411 * Display the character. We do tab expansion here because
412 * the screen interface doesn't have any way to set the tab
413 * length. Note, it's theoretically possible for chlen to
414 * be larger than cbuf, if the user set a impossibly large
424 if (cbp
+ chlen
>= ecbp
)
427 /* don't display half a wide character */
428 if (is_partial
&& CHAR_WIDTH(sp
, ch
) > 1) {
433 if (KEY_NEEDSWIDE(sp
, ch
))
437 KEY_NAME(sp
, ch
) + offset_in_char
;
443 if (scno
< cols_per_screen
) {
444 /* If didn't paint the whole line, update the cache. */
445 smp
->c_ecsize
= smp
->c_eclen
= KEY_COL(sp
, ch
);
446 smp
->c_eboff
= len
- 1;
449 * If not the info/mode line, and O_LIST set, and at the
450 * end of the line, and the line ended on this screen,
456 chlen
= KEY_LEN(sp
, '$');
457 if (cbp
+ chlen
>= ecbp
)
460 KEY_NAME(sp
, '$'); chlen
--;)
464 /* If still didn't paint the whole line, clear the rest. */
465 if (scno
< cols_per_screen
)
466 (void)gp
->scr_clrtoeol(sp
);
469 /* Flush any buffered characters. */
473 ret1
: (void)gp
->scr_move(sp
, oldy
, oldx
);
479 * Repaint the numbers on all the lines.
481 * PUBLIC: int vs_number(SCR *);
489 size_t len
, oldy
, oldx
;
496 /* No reason to do anything if we're in input mode on the info line. */
497 if (F_ISSET(sp
, SC_TINPUT_INFO
))
501 * Try and avoid getting the last line in the file, by getting the
502 * line after the last line in the screen -- if it exists, we know
503 * we have to to number all the lines in the screen. Get the one
504 * after the last instead of the last, so that the info line doesn't
505 * fool us. (The problem is that file_lline will lie, and tell us
506 * that the info line is the last line in the file.) If that test
507 * fails, we have to check each line for existence.
509 exist
= db_exist(sp
, TMAP
->lno
+ 1);
511 (void)gp
->scr_cursor(sp
, &oldy
, &oldx
);
512 for (smp
= HMAP
; smp
<= TMAP
; ++smp
) {
513 /* Numbers are only displayed for the first screen line. */
514 if (O_ISSET(sp
, O_LEFTRIGHT
)) {
522 * The first line of an empty file gets numbered, otherwise
523 * number any existing line.
525 if (smp
->lno
!= 1 && !exist
&& !db_exist(sp
, smp
->lno
))
528 (void)gp
->scr_move(sp
, smp
- HMAP
, 0);
529 len
= snprintf(nbuf
, sizeof(nbuf
), O_NUMBER_FMT
, (u_long
)smp
->lno
);
530 (void)gp
->scr_addstr(sp
, nbuf
, len
);
532 (void)gp
->scr_move(sp
, oldy
, oldx
);