| blob | 468de2cedab0da1608d8c3206d3d14be48725806 |
1 /*
2 * ========================================================================
3 * Copyright 2006-2008 University of Washington
4 * Copyright 2013-2022 Eduardo Chappa
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * ========================================================================
13 *
14 * Program: Display functions
15 *
16 */
18 /*
19 * The functions in this file handle redisplay. There are two halves, the
20 * ones that update the virtual display screen, and the ones that make the
21 * physical display screen the same as the virtual display screen. These
22 * functions use hints that are left in the windows by the commands.
23 *
24 */
29 #ifdef _WINDOWS
30 /* wingdi.h uses ERROR (!) and we aren't using the c-client ERROR so... */
31 #undef ERROR
32 #endif
55 #ifdef _WINDOWS
61 /*
62 * Standard pico keymenus...
63 */
71 #ifdef SPELLER
73 #else
75 #endif
76 };
77 #define UNCUT_KEY 10
84 /* TRANSLATORS: Justify is to reformat a paragraph automatically */
88 #ifdef SPELLER
90 #else
92 #endif
93 };
94 #define EXIT_KEY 1
95 #define PSTPN_KEY 5
96 #define WHERE_KEY 8
99 /*
100 * Definition's for pico's modeline
101 */
118 being displayed */
124 /*
125 * Initialize the data structures used by the display code. The edge vectors
126 * used to access the screens are set up. The operating system's terminal I/O
127 * channel is set up. All the other things get initialized at compile time.
128 * The original window has "WFCHG" set, so that it will get completely
129 * redrawn on the first call to "update".
130 */
131 int
133 {
136 CELL ac;
152 }
160 }
170 NULL);
172 }
173 else
188 }
193 NULL);
195 }
196 else
203 }
206 }
208 int
210 {
213 }
216 /*
217 * Clean up the virtual terminal system, in anticipation for a return to the
218 * operating system. Move down to the last line and clear it out (the next
219 * system prompt will be written in the line). Shut down the channel to the
220 * terminal.
221 */
222 void
224 {
230 }
233 /*
234 * Set the virtual cursor to the specified row and column on the virtual
235 * screen. There is no checking for nonsense values; this might be a good
236 * idea during the early stages.
237 */
238 void
240 {
249 /*
250 * This is unused so don't worry about it.
251 */
253 }
254 }
257 /*
258 * Write a character to the virtual screen. The virtual row and column are
259 * updated. If the line is too long put a "$" in the last column. This routine
260 * only puts printing characters into the virtual terminal buffers. Only
261 * column overflow is checked.
262 */
263 void
265 {
267 CELL ac;
276 /*
277 * What's this supposed to be doing? This sets vtcol
278 * to the even multiple of 8 >= vtcol. Why are we doing that?
279 * Must make tab work correctly.
280 * 24 -> 24
281 * 25 -> 32
282 * ...
283 * 31 -> 32
284 * 32 -> 32
285 * 33 -> 40
286 */
290 /*
291 * If we get to here that means that there must be characters
292 * past the right hand edge, so we want to put a $ character
293 * in the last visible character. It would be nice to replace
294 * the last visible character by a double-$ if it is double-width
295 * but we aren't doing that because we'd have to add up the widths
296 * starting at the left hand margin each time through.
297 */
300 }
304 }
306 }
312 }
315 /*
316 * Have to worry about what happens if we skip over 0
317 * with a double-width character. There may be a better
318 * place to be setting vtind, or maybe we could make do
319 * without it.
320 */
329 }
331 /*
332 * Double-width character overlaps right edge.
333 * Replace it with a $.
334 */
339 }
345 }
346 }
349 /*
350 * Erase from the end of the software cursor to the end of the line on which
351 * the software cursor is located.
352 */
353 void
355 {
357 CELL c;
368 }
370 int
372 {
389 }
390 }
395 }
397 change++;
403 }
406 /*
407 * Make sure that the display is right. This is a three part process. First,
408 * scan through all of the windows looking for dirty ones. Check the framing,
409 * and refresh the screen. Second, make sure that "currow" and "curcol" are
410 * correct for the current window. Third, make the virtual and physical
411 * screens the same.
412 */
413 void
415 {
424 CELL c;
427 #if TYPEAH
430 #endif
432 #ifdef _WINDOWS
433 /* This tells our MS Windows module to not bother updating the
434 * cursor position while a massive screen update is in progress.
435 */
437 #endif
439 /*
440 * BUG: setting and unsetting whole region at a time is dumb. fix this.
441 */
445 }
450 /* Look at any window with update flags set on. */
455 }
457 /* If not force reframe, check the framing. */
470 }
471 }
473 /* Not acceptable, better compute a new value for the line at the
474 * top of the window. Then set the "WFHARD" flag to force full
475 * redraw.
476 */
484 }
490 }
492 /*
493 * find dotp, if its been moved just above or below the
494 * window, use scrollxxx() to facilitate quick redisplay...
495 */
500 }
506 else
508 }
511 }
512 }
514 }
515 else
523 }
525 /*
526 * this is supposed to speed things up by using tcap sequences
527 * to efficiently scroll the terminal screen. the thinking here
528 * is that its much faster to update pscreen[] than to actually
529 * write the stuff to the screen...
530 */
535 /*
536 * do we scroll down the header as well? Well, only
537 * if we're not editing the header, we've backed up
538 * to the top, and the composer is not being
539 * displayed...
540 */
551 /*
552 * do we scroll down the header as well? Well, only
553 * if we're not editing the header, we've backed up
554 * to the top, and the composer is not being
555 * displayed...
556 */
561 else
563 }
564 else
569 }
570 }
574 out:
575 /*
576 * if the line at the top of the page is the top line
577 * in the body, show the header...
578 */
589 }
590 else
592 }
593 }
597 }
598 }
600 /* Try to use reduced update. Mode line update has its own special
601 * flag. The fast update is used if the only thing to do is within
602 * the line editing.
603 */
611 }
613 /* compute physical length of line in screen */
621 }
624 }
630 }
631 }
637 }
641 /* compute physical length of line in screen */
649 }
652 }
658 }
659 }
662 /* if line has been changed */
668 }
672 }
673 }
674 #if ~WFDEBUG
680 #endif
681 }
682 #if WFDEBUG
686 #endif
688 /* and onward to the next window */
690 }
692 /* Always recompute the row and column number of the hardware cursor. This
693 * is the only update for simple moves.
694 */
701 }
712 }
715 }
721 }
722 }
725 /* flag we are extended and changed */
731 /* make sure no lines need to be de-extended because the cursor is
732 * no longer on them
733 */
743 /* always flag extended lines as changed */
752 /* this line no longer is extended */
754 }
755 }
758 }
759 /* and onward to the next window */
761 }
763 /* Special hacking if the screen is garbage. Clear the hardware screen,
764 * and update your copy to agree with it. Set all the virtual screen
765 * change bits, to force a full update.
766 */
777 }
779 /*
780 * since we're using only a portion of the screen and only
781 * one buffer, only clear enough screen for the current window
782 * which is to say the *only* window.
783 */
788 }
795 }
807 }
808 }
812 }
813 }
820 else
822 }
824 /* Make sure that the physical and virtual displays agree. Unlike before,
825 * the "updateline" code is only called with a line that has been updated
826 * for sure.
827 */
830 else
835 else
842 /* for each line that needs to be updated, or that needs its
843 reverse video status changed, call the line updater */
847 #if TYPEAH
849 #ifdef _WINDOWS
851 #endif
853 }
854 #endif
858 }
859 }
869 }
872 /* TRANSLATORS: UnJustify means undo the previous
873 Justify command. */
878 }
879 }
880 else
885 }
886 }
891 }
893 /* Finally, update the hardware cursor and flush out buffers. */
896 #ifdef _WINDOWS
899 /*
900 * Update the scroll bars. This function is where curbp->b_linecnt
901 * is really managed. See update_scroll.
902 */
904 #endif
906 }
909 /* updext - update the extended line which the cursor is currently
910 * on at a column greater than the terminal width. The line
911 * will be scrolled right or left to let the user see where
912 * the cursor is
913 */
914 void
916 {
923 /*
924 * Calculate what column the real cursor will end up in.
925 * The cursor will be in the rcursor'th column. So if we're
926 * counting columns 0 1 2 3 and rcursor is 8, then rcursor
927 * will be over cell 7.
928 *
929 * What this effectively does is to scroll the screen as we're
930 * moving to the right when the cursor first passes off the
931 * screen's right edge. It would be nice if it did the same
932 * thing coming back to the left. Instead, in order that the
933 * screen's display depends only on the curcol and not on
934 * how we got there, the screen scrolls when we pass the
935 * t_margin column. It's also kind of funky that you can't
936 * see the character under the $ but you can delete it.
937 */
941 /*
942 * Make sure lbound is set so that a double-width character does
943 * not straddle the boundary. If it does, move over one cell.
944 */
949 }
955 /* scan through the line outputting characters to the virtual screen
956 * once we reach the left edge
957 */
962 /* truncate the virtual line */
965 /* and put a '$' in column 1, may have to adjust curcol */
970 /*
971 * We want to put $ in the first two columns so that it
972 * takes up the right amount of space, but that means we
973 * have to scoot the real characters over one slot.
974 */
980 }
981 }
983 /* update line color, to be executed to update lines when color is on */
984 void
986 {
998 }
1003 /* set up pointers to virtual and physical lines */
1015 }
1025 }
1027 /* go to start of line */
1039 /*
1040 * Draw all of the characters starting with cp1
1041 * until we get to all spaces, then clear to the end of
1042 * line from there. Watch out we don't run over the
1043 * right hand edge, which shouldn't happen.
1044 *
1045 * Set cp5 to the first of the repeating spaces.
1046 */
1050 }
1052 /*
1053 * In the !nbflag case we want spaces from cp5 on.
1054 * Setting cp3 to something different from cp5 triggers
1055 * the clear to end of line below.
1056 */
1058 cleartoeol++;
1059 }
1063 /*
1064 * No peeol so draw all the way to the edge whether they
1065 * are spaces or not.
1066 */
1073 }
1076 }
1077 }
1078 }
1091 }
1092 else
1100 }
1109 }
1114 else
1125 }
1130 }
1138 }
1142 /*
1143 * Update a single line. This does not know how to use insert or delete
1144 * character sequences; we are using VT52 functionality. Update the physical
1145 * row and column variables.
1146 */
1147 void
1153 {
1165 }
1167 /* set up pointers to virtual and physical lines */
1172 /* advance past any common chars at the left */
1176 }
1178 /* This can still happen, even though we only call this routine on changed
1179 * lines. A hard update is always done when a line splits, a massive
1180 * change is done, or a buffer is displayed twice. This optimizes out most
1181 * of the excess updating. A lot of computes are used, but these tend to
1182 * be hard operations that do a lot of update, so I don't really care.
1183 */
1184 /* if both lines are the same, no update needs to be done */
1188 }
1190 /* find out if there is a match on the right */
1201 }
1211 }
1213 /* go to start of differences */
1225 }
1235 }
1236 }
1242 }
1252 }
1253 }
1254 }
1259 /*
1260 * If we need to copy characters from cp1 to cp2 and
1261 * we need to display them, then we have to worry about
1262 * the characters that we are replacing being of a different
1263 * width than the new characters, else the display may be
1264 * messed up.
1265 *
1266 * If the new width (w1) is less than the old width, that means
1267 * we will leave behind some old remnants if we aren't careful.
1268 * If the new width is larger than the old width, we have to
1269 * make sure we draw the characters all the way to the end
1270 * in order to get it right. Take advantage of clear to end
1271 * of line if we have it.
1272 */
1279 /*
1280 * Draw all of the characters starting with cp1
1281 * until we get to all spaces, then clear to the end of
1282 * line from there. Watch out we don't run over the
1283 * right hand edge, which shouldn't happen.
1284 *
1285 * Set cp5 to the first of the repeating spaces.
1286 */
1290 }
1292 /*
1293 * In the !nbflag case we want spaces from cp5 on.
1294 * Setting cp3 to something different from cp5 triggers
1295 * the clear to end of line below.
1296 */
1298 cleartoeol++;
1299 }
1303 /*
1304 * No peeol so draw all the way to the edge whether they
1305 * are spaces or not.
1306 */
1313 }
1316 }
1317 }
1318 }
1326 }
1332 }
1339 else
1342 }
1345 }
1348 /*
1349 * Redisplay the mode line for the window pointed to by the "wp". This is the
1350 * only routine that has any idea of how the modeline is formatted. You can
1351 * change the modeline format by hacking at this routine. Called by "update"
1352 * any time there is a dirty window.
1353 */
1354 void
1356 {
1375 }
1376 }
1396 }
1401 }
1402 else
1405 #define ALLOFTHEM (w1+w1_to_2+w2+w2_to_3+w3+w3_to_r)
1406 #define ALLBUTSPACE (w1+w2+w3+w3_to_r)
1417 }
1431 }
1438 /* reduce size of file */
1443 }
1444 else
1453 else
1455 }
1456 }
1457 }
1458 }
1459 }
1476 CELL c;
1484 }
1485 }
1486 }
1490 /*
1491 * Send a command to the terminal to move the hardware cursor to row "row"
1492 * and column "col". The row and column arguments are origin 0. Optimize out
1493 * random calls. Update "ttrow" and "ttcol".
1494 */
1495 void
1497 {
1502 }
1503 }
1506 /*
1507 * Erase any sense we have of the cursor's HW location...
1508 */
1509 void
1511 {
1513 }
1515 void
1517 {
1522 }
1525 /*
1526 * Erase the message line. This is a special routine because the message line
1527 * is not considered to be part of the virtual screen. It always works
1528 * immediately; the terminal buffer is flushed via a call to the flusher.
1529 */
1530 void
1532 {
1544 }
1548 }
1549 }
1553 }
1555 /* returns the chosen dictionary. If one was already chosen
1556 * return that one
1557 */
1560 {
1571 ;
1585 EXTRAKEYS menu_dictionary[] = {
1596 };
1604 /* write the prompt in utf8, and let internal functions translate it to ucs4 */
1617 }
1624 }
1626 /* just like mlreplyd, but user cannot fill a prompt */
1627 int
1629 {
1630 UCS c;
1640 }
1654 }
1658 }
1659 }
1672 }
1673 else
1680 ;
1698 }
1699 else
1708 }
1709 else
1713 km_popped++;
1715 }
1716 /* else fall through */
1722 }
1729 }
1730 else
1739 }
1742 }
1743 }
1744 }
1747 int
1749 {
1761 }
1764 /*
1765 * Ask a yes or no question in the message line. Return either TRUE, FALSE, or
1766 * ABORT. The ABORT status is returned if the user bumps out of the question
1767 * with a ^G. if d >= 0, d is the default answer returned. Otherwise there
1768 * is no default.
1769 */
1770 int
1772 {
1779 #ifdef _WINDOWS
1786 }
1787 #endif
1792 }
1825 }
1826 else
1859 }
1860 else
1869 }
1870 else
1874 km_popped++;
1876 }
1877 /* else fall through */
1883 }
1890 }
1891 else
1900 }
1903 }
1904 }
1905 }
1908 /*
1909 * Write a prompt into the message line, then read back a response. Keep
1910 * track of the physical position of the cursor. If we are in a keyboard
1911 * macro throw the prompt away, and return the remembered response. This
1912 * lets macros run at full speed. The reply is always terminated by a carriage
1913 * return. Handle erase, kill, and abort keys.
1914 */
1915 int
1917 {
1919 }
1922 int
1924 {
1926 }
1929 /*
1930 * function key mappings
1931 */
1945 };
1948 int
1950 {
1962 }
1973 }
1982 }
1985 void
1987 {
1989 }
1992 /*
1993 * mlreplyd - write the prompt to the message line along with a default
1994 * answer already typed in. Carriage return accepts the
1995 * default. answer returned in buf which also holds the initial
1996 * default, nbuf is its length, def set means use default value.
1997 * In order to be able to eliminate keys from a menu, EXTRAKEYS
1998 * always has size 10.
1999 */
2000 int
2002 {
2015 #ifdef _WINDOWS
2030 else
2038 j++;
2039 }
2040 }
2055 }
2058 }
2059 #endif
2076 }
2077 }
2078 }
2093 }
2094 }
2095 }
2097 /* set up what to watch for and return values */
2136 }
2137 else
2145 #ifdef MOUSE
2150 #endif
2151 #ifdef _WINDOWS
2153 #endif
2155 ;
2157 #ifdef MOUSE
2159 #endif
2160 #ifdef _WINDOWS
2162 #endif
2174 else
2175 b--;
2194 else
2195 b++;
2204 km_popped++;
2209 }
2210 else
2219 }
2220 else
2225 }
2236 }
2237 else
2238 b--;
2245 }
2274 #ifdef MOUSE
2276 {
2277 MOUSEPRESS mp;
2281 /* The clicked line have anything special on it? */
2291 #ifdef _WINDOWS
2296 #endif
2301 }
2302 }
2305 #endif
2309 /* look for match in extra_v */
2314 }
2320 }
2327 }
2328 }
2333 }
2341 }
2342 }
2343 }
2345 ret:
2349 }
2350 else
2361 }
2370 }
2373 void
2375 {
2378 }
2380 void
2382 {
2391 }
2394 /*
2395 * emlwrite() - write the message string to the error half of the screen
2396 * center justified. much like mlwrite (which is still used
2397 * to paint the line for prompts and such), except it center
2398 * the text.
2399 */
2400 void
2402 {
2417 /*
2418 * next, figure out where the to move the cursor so the message
2419 * comes out centered
2420 */
2443 }
2444 }
2448 else
2455 }
2456 else
2470 }
2491 }
2492 }
2493 else
2495 bufp++;
2496 }
2503 }
2504 else
2510 }
2513 int
2515 {
2525 }
2528 /*
2529 * Write a message into the message line. Keep track of the physical cursor
2530 * position. A small class of printf like format items is handled. Assumes the
2531 * stack grows down; this assumption is made by the "++" in the argument scan
2532 * loop. Set the "message line" flag TRUE.
2533 */
2534 int
2536 {
2538 UCS c;
2543 /*
2544 * the idea is to only highlight if there is something to show
2545 */
2553 }
2554 else
2562 }
2595 }
2596 }
2597 }
2608 }
2609 else
2616 }
2619 /*
2620 * Write out an integer, in the specified radix. Update the physical cursor
2621 * position. This will not handle any negative numbers; maybe it should.
2622 */
2623 void
2625 {
2632 }
2640 }
2643 /*
2644 * do the same except as a long integer.
2645 */
2646 void
2648 {
2654 }
2662 }
2665 void
2667 {
2669 EML eml;
2675 /* fall through */
2676 }
2680 }
2681 else
2724 }
2729 }
2732 /*
2733 * scrolldown - use stuff to efficiently move blocks of text on the
2734 * display, and update the pscreen array to reflect those
2735 * moves...
2736 *
2737 * wp is the window to move in
2738 * r is the row at which to begin scrolling
2739 * n is the number of lines to scrol
2740 */
2741 void
2743 {
2744 #ifdef TERMCAP
2756 }
2761 }
2769 }
2774 }
2777 /*
2778 * scrollup - use tcap stuff to efficiently move blocks of text on the
2779 * display, and update the pscreen array to reflect those
2780 * moves...
2781 */
2782 void
2784 {
2785 #ifdef TERMCAP
2803 }
2807 }
2811 i++;
2812 }
2817 }
2820 /*
2821 * print spaces in the physical screen starting from row abs(n) working in
2822 * either the positive or negative direction (depending on sign of n).
2823 */
2824 void
2826 {
2835 }
2836 }
2837 }
2843 }
2844 }
2845 }
2848 }
2851 /*
2852 * doton - return the physical line number that the dot is on in the
2853 * current window, and by side effect the number of lines remaining
2854 */
2855 int
2857 {
2870 i++;
2872 }
2875 }
2878 }
2882 /*
2883 * resize_pico - given new window dimensions, allocate new resources
2884 */
2885 int
2887 {
2904 }
2909 }
2912 else
2915 /*
2916 * free unused screen space ...
2917 */
2921 }
2923 /*
2924 * realloc new space for screen ...
2925 */
2929 else
2931 }
2936 else
2938 }
2943 else
2954 }
2958 else
2966 }
2971 }
2976 }
2977 }
2980 }
2982 void
2984 {
2987 }
2990 /*
2991 * showCompTitle - display the anchor line passed in from pine
2992 */
2993 void
2995 {
3009 }
3010 else
3016 else
3022 }
3023 else
3028 }
3029 }
3033 /*
3034 * zotdisplay - blast malloc'd space created for display maps
3035 */
3036 void
3038 {
3044 }
3048 }
3052 /*
3053 * nlforw() - returns the number of lines from the top to the dot
3054 */
3055 int
3057 {
3063 i++;
3064 }
3066 }
3070 /*
3071 * pputc - output the given char, keep track of it on the physical screen
3072 * array, and keep track of the cursor
3073 */
3074 void
3077 {
3080 /*
3081 * This is necessary but not sufficient to allow us to draw. Note that
3082 * ttrow runs from 0 to t_nrow (so total number of rows is t_nrow+1)
3083 * ttcol runs from 0 to t_ncol-1 (so total number of cols is t_ncol)
3084 */
3087 /*
3088 * Width is the number of screen columns a character will occupy.
3089 */
3091 printable_ascii++;
3093 }
3094 else
3101 /*
3102 * Some terminals scroll when you write in the lower right corner
3103 * of the screen, so don't write there.
3104 */
3110 }
3111 }
3113 /*
3114 * Character overlaps right edge of screen. Hopefully the higher
3115 * layers will prevent this but we're making sure.
3116 *
3117 * We may want to do something like writing a space character
3118 * into the cells that are on the screen. We'll see.
3119 */
3120 }
3123 }
3124 }
3127 /*
3128 * pputs - print a string and keep track of the cursor
3129 */
3130 void
3133 {
3136 }
3139 void
3141 {
3149 }
3150 }
3151 }
3154 /*
3155 * peeol - physical screen array erase to end of the line. remember to
3156 * track the cursor.
3157 */
3158 void
3160 {
3162 CELL cl;
3170 /*
3171 * Don't clear if we think we are sitting past the last column,
3172 * that erases the last column if we just wrote it.
3173 */
3177 /*
3178 * Because the characters are variable width it's a little tricky
3179 * to erase the rest of the line. What we do is add up the
3180 * widths of the characters until we reach ttcol
3181 * then set the rest to the space character.
3182 */
3186 }
3190 }
3193 /*
3194 * pscr - return the character cell on the physical screen map on the
3195 * given line, l, and offset, o.
3196 */
3197 CELL *
3199 {
3202 else
3204 }
3207 /*
3208 * pclear() - clear the physical screen from row x through row y (inclusive)
3209 * row is zero origin, min row = 0 max row = t_nrow
3210 * Clear whole screen -- pclear(0, term.t_nrow)
3211 * Clear bottom two rows -- pclear(term.t_nrow-1, term.t_nrow)
3212 * Clear bottom three rows -- pclear(term.t_nrow-2, term.t_nrow)
3213 */
3214 void
3216 {
3225 }
3226 }
3229 /*
3230 * dumbroot - just get close
3231 */
3232 int
3234 {
3237 else
3239 }
3242 /*
3243 * dumblroot - just get close
3244 */
3245 int
3247 {
3250 else
3252 }
3255 /*
3256 * pinsertc - use optimized insert, fixing physical screen map.
3257 * returns true if char written, false otherwise
3258 */
3259 int
3261 {
3282 }
3285 }
3288 /*
3289 * pdel - use optimized delete to rub out the current char and
3290 * fix the physical screen array.
3291 * returns true if optimized the delete, false otherwise
3292 */
3293 int
3295 {
3315 }
3317 /* then clean up physical screen */
3323 }
3326 }
3329 }
3333 /*
3334 * wstripe - write out the given string at the given location, and reverse
3335 * video on flagged characters. Does the same thing as pine's
3336 * stripe.
3337 *
3338 * I believe this needs to be fixed to work with non-ascii utf8pmt, but maybe
3339 * only if you want to put the tildes before multi-byte chars.
3340 */
3341 void
3343 {
3361 }
3365 }
3375 }
3378 j++;
3384 }
3388 j--;
3390 }
3394 j++;
3395 i++;
3396 }
3403 u++;
3406 else
3412 else
3414 }
3417 }
3418 }
3428 }
3430 }
3434 /*
3435 * wkeyhelp - paint list of possible commands on the bottom
3436 * of the display (yet another pine clone)
3437 * NOTE: function key mode is handled here since all the labels
3438 * are the same...
3439 *
3440 * The KEYMENU definitions have names and labels defined as UTF-8 strings,
3441 * and wstripe expects UTF-8.
3442 */
3443 void
3445 {
3449 #ifdef MOUSE
3451 #endif
3453 #ifdef _WINDOWS
3455 #endif
3463 /*
3464 * Calculate amount of space for the names column by column...
3465 */
3475 }
3476 else
3481 /*
3482 * Avoid writing in bottom right corner so we won't scroll screens that
3483 * scroll when you do that. The way this is setup, we won't do that
3484 * unless the number of columns is evenly divisible by 6.
3485 */
3497 if(keymenu[index].label[0] == '[' && keymenu[index].label[(l=strlen(keymenu[index].label))-1] == ']' && l > 2){
3501 }
3502 else
3510 }
3511 else
3513 #ifdef MOUSE
3530 #endif
3536 }
3549 }
3555 #ifdef MOUSE
3557 #endif
3558 }
3561 index++;
3562 }
3565 }
3566 }
3569 /*
3570 * This returns the screen width between pstart (inclusive) and
3571 * pend (exclusive) where the pointers point into an array of CELLs.
3572 */
3573 unsigned
3575 {
3584 }
3587 }
3590 /*
3591 * This returns the virtual screen width in row from index a to b (exclusive).
3592 */
3593 unsigned
3595 {
3613 }
3616 /*
3617 * This returns the physical screen width in row from index a to b (exclusive).
3618 */
3619 unsigned
3621 {
3639 }
3642 int
3644 {
3661 }
3662 else
3664 }
3666 /* MIN and MAX just to be sure */
3668 }
3670 #ifdef _WINDOWS
3672 void
3674 {
3677 UCS key;
3681 /* keymenu's seem to be hardcoded at 12 entries. */
3690 else
3694 }
3695 }
3696 }
3698 /*
3699 * Update the scroll range and position. (exported)
3700 *
3701 * This is where curbp->b_linecnt is really managed. With out this function
3702 * to count the number of lines when needed curbp->b_linecnt will never
3703 * really be correct. BUT, this function is only compiled into the
3704 * windows version, so b_linecnt will only ever be right in the windows
3705 * version. OK for now because that is the only version that
3706 * looks at b_linecnt.
3707 */
3708 int
3710 {
3719 /* Editing header - don't allow scroll bars. */
3722 }
3725 /*
3726 * Count the number of lines in the current buffer. Done when:
3727 *
3728 * when told to recount: curbp->b_linecnt == -1
3729 * when the top line changed: curwp->w_linep != last_top_line
3730 * when we don't know the scroll pos: last_scroll_pos == -1
3731 *
3732 * The first line in the list is a "place holder" line and is not
3733 * counted. The list is circular, when we return the to place
3734 * holder we have reached the end.
3735 */
3746 }
3751 }
3753 /*
3754 * Set new scroll range and position.
3755 */
3759 }