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.
13 static const char sccsid
[] = "$Id: vs_line.c,v 10.34 2001/06/25 15:19:37 skimo Exp $ (Berkeley) $Date: 2001/06/25 15:19:37 $";
16 #include <sys/types.h>
17 #include <sys/queue.h>
20 #include <bitstring.h>
25 #include "../common/common.h"
28 #ifdef VISIBLE_TAB_CHARS
36 * Update one line on the screen.
38 * PUBLIC: int vs_line __P((SCR *, SMAP *, size_t *, size_t *));
41 vs_line(SCR
*sp
, SMAP
*smp
, size_t *yp
, size_t *xp
)
46 size_t chlen
, cno_cnt
, cols_per_screen
, len
, nlen
;
47 size_t offset_in_char
, offset_in_line
, oldx
, oldy
;
48 size_t scno
, skip_cols
, skip_screens
;
49 int dne
, is_cached
, is_partial
, is_tab
, no_draw
;
50 int list_tab
, list_dollar
;
52 CHAR_T
*cbp
, *ecbp
, cbuf
[128];
55 #if defined(DEBUG) && 0
56 vtrace(sp
, "vs_line: row %u: line: %u off: %u\n",
57 smp
- HMAP
, smp
->lno
, smp
->off
);
60 * If ex modifies the screen after ex output is already on the screen,
61 * don't touch it -- we'll get scrolling wrong, at best.
64 if (!F_ISSET(sp
, SC_TINPUT_INFO
) && VIP(sp
)->totalcount
> 1)
66 if (F_ISSET(sp
, SC_SCR_EXWROTE
) && smp
- HMAP
!= LASTLINE(sp
))
70 * Assume that, if the cache entry for the line is filled in, the
71 * line is already on the screen, and all we need to do is return
72 * the cursor position. If the calling routine doesn't need the
73 * cursor position, we can just return.
75 is_cached
= SMAP_CACHE(smp
);
76 if (yp
== NULL
&& (is_cached
|| no_draw
))
80 * A nasty side effect of this routine is that it returns the screen
81 * position for the "current" character. Not pretty, but this is the
82 * only routine that really knows what's out there.
84 * Move to the line. This routine can be called by vs_sm_position(),
85 * which uses it to fill in the cache entry so it can figure out what
86 * the real contents of the screen are. Because of this, we have to
87 * return to whereever we started from.
90 (void)gp
->scr_cursor(sp
, &oldy
, &oldx
);
91 (void)gp
->scr_move(sp
, smp
- HMAP
, 0);
94 dne
= db_get(sp
, smp
->lno
, 0, &p
, &len
);
97 * Special case if we're printing the info/mode line. Skip printing
98 * the leading number, as well as other minor setup. The only time
99 * this code paints the mode line is when the user is entering text
100 * for a ":" command, so we can put the code here instead of dealing
101 * with the empty line logic below. This is a kludge, but it's pretty
102 * much confined to this module.
104 * Set the number of columns for this screen.
105 * Set the number of chars or screens to skip until a character is to
108 cols_per_screen
= sp
->cols
;
109 if (O_ISSET(sp
, O_LEFTRIGHT
)) {
111 skip_cols
= smp
->coff
;
113 skip_screens
= smp
->soff
- 1;
114 skip_cols
= skip_screens
* cols_per_screen
;
117 list_tab
= O_ISSET(sp
, O_LIST
);
118 if (F_ISSET(sp
, SC_TINPUT_INFO
))
121 list_dollar
= list_tab
;
124 * If O_NUMBER is set, the line doesn't exist and it's line
125 * number 1, i.e., an empty file, display the line number.
127 * If O_NUMBER is set, the line exists and the first character
128 * on the screen is the first character in the line, display
132 * If O_NUMBER set, decrement the number of columns in the
133 * first screen. DO NOT CHANGE THIS -- IT'S RIGHT! The
134 * rest of the code expects this to reflect the number of
135 * columns in the first screen, regardless of the number of
136 * columns we're going to skip.
138 if (O_ISSET(sp
, O_NUMBER
)) {
139 cols_per_screen
-= O_NUMBER_LENGTH
;
140 if ((!dne
|| smp
->lno
== 1) && skip_cols
== 0) {
141 nlen
= snprintf((char*)cbuf
,
142 sizeof(cbuf
), O_NUMBER_FMT
, smp
->lno
);
143 (void)gp
->scr_addstr(sp
, (char*)cbuf
, nlen
);
149 * Special case non-existent lines and the first line of an empty
150 * file. In both cases, the cursor position is 0, but corrected
151 * as necessary for the O_NUMBER field, if it was displayed.
153 if (dne
|| len
== 0) {
154 /* Fill in the cursor. */
155 if (yp
!= NULL
&& smp
->lno
== sp
->lno
) {
157 *xp
= sp
->cols
- cols_per_screen
;
160 /* If the line is on the screen, quit. */
161 if (is_cached
|| no_draw
)
164 /* Set line cache information. */
165 smp
->c_sboff
= smp
->c_eboff
= 0;
166 smp
->c_scoff
= smp
->c_eclen
= 0;
169 * Lots of special cases for empty lines, but they only apply
170 * if we're displaying the first screen of the line.
186 empty
: (void)gp
->scr_addstr(sp
,
187 KEY_NAME(sp
, ch
), KEY_LEN(sp
, ch
));
190 (void)gp
->scr_clrtoeol(sp
);
191 (void)gp
->scr_move(sp
, oldy
, oldx
);
196 * If we just wrote this or a previous line, we cached the starting
197 * and ending positions of that line. The way it works is we keep
198 * information about the lines displayed in the SMAP. If we're
199 * painting the screen in the forward direction, this saves us from
200 * reformatting the physical line for every line on the screen. This
201 * wins big on binary files with 10K lines.
203 * Test for the first screen of the line, then the current screen line,
204 * then the line behind us, then do the hard work. Note, it doesn't
205 * do us any good to have a line in front of us -- it would be really
206 * hard to try and figure out tabs in the reverse direction, i.e. how
207 * many spaces a tab takes up in the reverse direction depends on
208 * what characters preceded it.
210 * Test for the first screen of the line.
212 if (skip_cols
== 0) {
213 smp
->c_sboff
= offset_in_line
= 0;
214 smp
->c_scoff
= offset_in_char
= 0;
215 p
= &p
[offset_in_line
];
219 /* Test to see if we've seen this exact line before. */
221 offset_in_line
= smp
->c_sboff
;
222 offset_in_char
= smp
->c_scoff
;
223 p
= &p
[offset_in_line
];
225 /* Set cols_per_screen to 2nd and later line length. */
226 if (O_ISSET(sp
, O_LEFTRIGHT
) || skip_cols
> cols_per_screen
)
227 cols_per_screen
= sp
->cols
;
231 /* Test to see if we saw an earlier part of this line before. */
233 SMAP_CACHE(tsmp
= smp
- 1) && tsmp
->lno
== smp
->lno
) {
234 if (tsmp
->c_eclen
!= tsmp
->c_ecsize
) {
235 offset_in_line
= tsmp
->c_eboff
;
236 offset_in_char
= tsmp
->c_eclen
;
238 offset_in_line
= tsmp
->c_eboff
+ 1;
242 /* Put starting info for this line in the cache. */
243 smp
->c_sboff
= offset_in_line
;
244 smp
->c_scoff
= offset_in_char
;
245 p
= &p
[offset_in_line
];
247 /* Set cols_per_screen to 2nd and later line length. */
248 if (O_ISSET(sp
, O_LEFTRIGHT
) || skip_cols
> cols_per_screen
)
249 cols_per_screen
= sp
->cols
;
257 /* Do it the hard way, for leftright scrolling screens. */
258 if (O_ISSET(sp
, O_LEFTRIGHT
)) {
259 for (; offset_in_line
< len
; ++offset_in_line
) {
260 chlen
= (ch
= *p
++) == L('\t') && !list_tab
?
261 TAB_OFF(scno
) : KEY_COL(sp
, ch
);
262 if ((scno
+= chlen
) >= skip_cols
)
266 /* Set cols_per_screen to 2nd and later line length. */
267 cols_per_screen
= sp
->cols
;
269 /* Put starting info for this line in the cache. */
270 if (scno
!= skip_cols
) {
271 smp
->c_sboff
= offset_in_line
;
273 offset_in_char
= chlen
- (scno
- skip_cols
);
276 smp
->c_sboff
= ++offset_in_line
;
281 /* Do it the hard way, for historic line-folding screens. */
283 for (; offset_in_line
< len
; ++offset_in_line
) {
284 chlen
= (ch
= *p
++) == L('\t') && !list_tab
?
285 TAB_OFF(scno
) : KEY_COL(sp
, ch
);
286 if ((scno
+= chlen
) < cols_per_screen
)
288 scno
-= cols_per_screen
;
290 /* Set cols_per_screen to 2nd and later line length. */
291 cols_per_screen
= sp
->cols
;
294 * If crossed the last skipped screen boundary, start
295 * displaying the characters.
297 if (--skip_screens
== 0)
301 /* Put starting info for this line in the cache. */
303 smp
->c_sboff
= offset_in_line
;
304 smp
->c_scoff
= offset_in_char
= chlen
- scno
;
307 smp
->c_sboff
= ++offset_in_line
;
314 * Set the number of characters to skip before reaching the cursor
315 * character. Offset by 1 and use 0 as a flag value. Vs_line is
316 * called repeatedly with a valid pointer to a cursor position.
317 * Don't fill anything in unless it's the right line and the right
318 * character, and the right part of the character...
321 smp
->lno
!= sp
->lno
|| sp
->cno
< offset_in_line
||
322 offset_in_line
+ cols_per_screen
< sp
->cno
) {
324 /* If the line is on the screen, quit. */
325 if (is_cached
|| no_draw
)
328 cno_cnt
= (sp
->cno
- offset_in_line
) + 1;
330 /* This is the loop that actually displays characters. */
331 ecbp
= (cbp
= cbuf
) + sizeof(cbuf
)/sizeof(CHAR_T
) - 1;
332 for (is_partial
= 0, scno
= 0;
333 offset_in_line
< len
; ++offset_in_line
, offset_in_char
= 0) {
334 if ((ch
= *p
++) == L('\t') && !list_tab
) {
335 scno
+= chlen
= TAB_OFF(scno
) - offset_in_char
;
338 scno
+= chlen
= KEY_COL(sp
, ch
) - offset_in_char
;
343 * Only display up to the right-hand column. Set a flag if
344 * the entire character wasn't displayed for use in setting
345 * the cursor. If reached the end of the line, set the cache
346 * info for the screen. Don't worry about there not being
347 * characters to display on the next screen, its lno/off won't
348 * match up in that case.
350 if (scno
>= cols_per_screen
) {
352 chlen
-= scno
- cols_per_screen
;
353 smp
->c_ecsize
= smp
->c_eclen
= chlen
;
354 scno
= cols_per_screen
;
356 smp
->c_ecsize
= chlen
;
357 chlen
-= scno
- cols_per_screen
;
358 smp
->c_eclen
= chlen
;
360 if (scno
> cols_per_screen
)
363 smp
->c_eboff
= offset_in_line
;
365 /* Terminate the loop. */
366 offset_in_line
= len
;
370 * If the caller wants the cursor value, and this was the
371 * cursor character, set the value. There are two ways to
372 * put the cursor on a character -- if it's normal display
373 * mode, it goes on the last column of the character. If
374 * it's input mode, it goes on the first. In normal mode,
375 * set the cursor only if the entire character was displayed.
378 --cno_cnt
== 0 && (F_ISSET(sp
, SC_TINPUT
) || !is_partial
)) {
380 if (F_ISSET(sp
, SC_TINPUT
))
382 *xp
= scno
- smp
->c_ecsize
;
387 if (O_ISSET(sp
, O_NUMBER
) &&
388 !F_ISSET(sp
, SC_TINPUT_INFO
) && skip_cols
== 0)
389 *xp
+= O_NUMBER_LENGTH
;
391 /* If the line is on the screen, quit. */
392 if (is_cached
|| no_draw
)
396 /* If the line is on the screen, don't display anything. */
397 if (is_cached
|| no_draw
)
402 (void)gp->scr_waddstr(sp, cbuf, cbp - cbuf); \
406 * Display the character. We do tab expansion here because
407 * the screen interface doesn't have any way to set the tab
408 * length. Note, it's theoretically possible for chlen to
409 * be larger than cbuf, if the user set a impossibly large
419 if (cbp
+ chlen
>= ecbp
)
422 /* don't display half a wide character */
423 if (is_partial
&& CHAR_WIDTH(sp
, ch
) > 1) {
431 for (kp
= KEY_NAME(sp
, ch
) + offset_in_char
;
433 *cbp
++ = (u_char
)*kp
++;
437 if (scno
< cols_per_screen
) {
438 /* If didn't paint the whole line, update the cache. */
439 smp
->c_ecsize
= smp
->c_eclen
= KEY_LEN(sp
, ch
);
440 smp
->c_eboff
= len
- 1;
443 * If not the info/mode line, and O_LIST set, and at the
444 * end of the line, and the line ended on this screen,
450 chlen
= KEY_LEN(sp
, '$');
451 if (cbp
+ chlen
>= ecbp
)
453 for (kp
= KEY_NAME(sp
, '$'); chlen
--;)
457 /* If still didn't paint the whole line, clear the rest. */
458 if (scno
< cols_per_screen
)
459 (void)gp
->scr_clrtoeol(sp
);
462 /* Flush any buffered characters. */
466 ret1
: (void)gp
->scr_move(sp
, oldy
, oldx
);
472 * Repaint the numbers on all the lines.
474 * PUBLIC: int vs_number __P((SCR *));
482 size_t len
, oldy
, oldx
;
489 /* No reason to do anything if we're in input mode on the info line. */
490 if (F_ISSET(sp
, SC_TINPUT_INFO
))
494 * Try and avoid getting the last line in the file, by getting the
495 * line after the last line in the screen -- if it exists, we know
496 * we have to to number all the lines in the screen. Get the one
497 * after the last instead of the last, so that the info line doesn't
498 * fool us. (The problem is that file_lline will lie, and tell us
499 * that the info line is the last line in the file.) If that test
500 * fails, we have to check each line for existence.
502 exist
= db_exist(sp
, TMAP
->lno
+ 1);
504 (void)gp
->scr_cursor(sp
, &oldy
, &oldx
);
505 for (smp
= HMAP
; smp
<= TMAP
; ++smp
) {
506 /* Numbers are only displayed for the first screen line. */
507 if (O_ISSET(sp
, O_LEFTRIGHT
)) {
515 * The first line of an empty file gets numbered, otherwise
516 * number any existing line.
518 if (smp
->lno
!= 1 && !exist
&& !db_exist(sp
, smp
->lno
))
521 (void)gp
->scr_move(sp
, smp
- HMAP
, 0);
522 len
= snprintf(nbuf
, sizeof(nbuf
), O_NUMBER_FMT
, smp
->lno
);
523 (void)gp
->scr_addstr(sp
, nbuf
, len
);
525 (void)gp
->scr_move(sp
, oldy
, oldx
);