| blob | 705dae109eeef3b13066e20b455d7be32770af88 |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2006-2008 University of Washington
8 * Copyright 2013-2020 Eduardo Chappa
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * ========================================================================
17 *
18 * Program: Display functions
19 *
20 */
22 /*
23 * The functions in this file handle redisplay. There are two halves, the
24 * ones that update the virtual display screen, and the ones that make the
25 * physical display screen the same as the virtual display screen. These
26 * functions use hints that are left in the windows by the commands.
27 *
28 */
33 #ifdef _WINDOWS
34 /* wingdi.h uses ERROR (!) and we aren't using the c-client ERROR so... */
35 #undef ERROR
36 #endif
59 #ifdef _WINDOWS
65 /*
66 * Standard pico keymenus...
67 */
75 #ifdef SPELLER
77 #else
79 #endif
80 };
81 #define UNCUT_KEY 10
88 /* TRANSLATORS: Justify is to reformat a paragraph automatically */
92 #ifdef SPELLER
94 #else
96 #endif
97 };
98 #define EXIT_KEY 1
99 #define PSTPN_KEY 5
100 #define WHERE_KEY 8
103 /*
104 * Definition's for pico's modeline
105 */
122 being displayed */
128 /*
129 * Initialize the data structures used by the display code. The edge vectors
130 * used to access the screens are set up. The operating system's terminal I/O
131 * channel is set up. All the other things get initialized at compile time.
132 * The original window has "WFCHG" set, so that it will get completely
133 * redrawn on the first call to "update".
134 */
135 int
137 {
140 CELL ac;
156 }
164 }
174 NULL);
176 }
177 else
192 }
197 NULL);
199 }
200 else
207 }
210 }
212 int
214 {
217 }
220 /*
221 * Clean up the virtual terminal system, in anticipation for a return to the
222 * operating system. Move down to the last line and clear it out (the next
223 * system prompt will be written in the line). Shut down the channel to the
224 * terminal.
225 */
226 void
228 {
234 }
237 /*
238 * Set the virtual cursor to the specified row and column on the virtual
239 * screen. There is no checking for nonsense values; this might be a good
240 * idea during the early stages.
241 */
242 void
244 {
253 /*
254 * This is unused so don't worry about it.
255 */
257 }
258 }
261 /*
262 * Write a character to the virtual screen. The virtual row and column are
263 * updated. If the line is too long put a "$" in the last column. This routine
264 * only puts printing characters into the virtual terminal buffers. Only
265 * column overflow is checked.
266 */
267 void
269 {
271 CELL ac;
280 /*
281 * What's this supposed to be doing? This sets vtcol
282 * to the even multiple of 8 >= vtcol. Why are we doing that?
283 * Must make tab work correctly.
284 * 24 -> 24
285 * 25 -> 32
286 * ...
287 * 31 -> 32
288 * 32 -> 32
289 * 33 -> 40
290 */
294 /*
295 * If we get to here that means that there must be characters
296 * past the right hand edge, so we want to put a $ character
297 * in the last visible character. It would be nice to replace
298 * the last visible character by a double-$ if it is double-width
299 * but we aren't doing that because we'd have to add up the widths
300 * starting at the left hand margin each time through.
301 */
304 }
308 }
310 }
316 }
319 /*
320 * Have to worry about what happens if we skip over 0
321 * with a double-width character. There may be a better
322 * place to be setting vtind, or maybe we could make do
323 * without it.
324 */
333 }
335 /*
336 * Double-width character overlaps right edge.
337 * Replace it with a $.
338 */
343 }
349 }
350 }
353 /*
354 * Erase from the end of the software cursor to the end of the line on which
355 * the software cursor is located.
356 */
357 void
359 {
361 CELL c;
372 }
374 int
376 {
393 }
394 }
399 }
401 change++;
407 }
410 /*
411 * Make sure that the display is right. This is a three part process. First,
412 * scan through all of the windows looking for dirty ones. Check the framing,
413 * and refresh the screen. Second, make sure that "currow" and "curcol" are
414 * correct for the current window. Third, make the virtual and physical
415 * screens the same.
416 */
417 void
419 {
429 CELL c;
432 #if TYPEAH
435 #endif
437 #ifdef _WINDOWS
438 /* This tells our MS Windows module to not bother updating the
439 * cursor position while a massive screen update is in progress.
440 */
442 #endif
444 /*
445 * BUG: setting and unsetting whole region at a time is dumb. fix this.
446 */
450 }
455 /* Look at any window with update flags set on. */
460 }
462 /* If not force reframe, check the framing. */
475 }
476 }
478 /* Not acceptable, better compute a new value for the line at the
479 * top of the window. Then set the "WFHARD" flag to force full
480 * redraw.
481 */
489 }
495 }
497 /*
498 * find dotp, if its been moved just above or below the
499 * window, use scrollxxx() to facilitate quick redisplay...
500 */
505 }
511 else
513 }
516 }
517 }
519 }
520 else
528 }
530 /*
531 * this is supposed to speed things up by using tcap sequences
532 * to efficiently scroll the terminal screen. the thinking here
533 * is that its much faster to update pscreen[] than to actually
534 * write the stuff to the screen...
535 */
540 /*
541 * do we scroll down the header as well? Well, only
542 * if we're not editing the header, we've backed up
543 * to the top, and the composer is not being
544 * displayed...
545 */
556 /*
557 * do we scroll down the header as well? Well, only
558 * if we're not editing the header, we've backed up
559 * to the top, and the composer is not being
560 * displayed...
561 */
566 else
568 }
569 else
574 }
575 }
579 out:
580 /*
581 * if the line at the top of the page is the top line
582 * in the body, show the header...
583 */
594 }
595 else
597 }
598 }
602 }
603 }
605 /* Try to use reduced update. Mode line update has its own special
606 * flag. The fast update is used if the only thing to do is within
607 * the line editing.
608 */
616 }
618 /* compute physical length of line in screen */
626 }
629 }
635 }
636 }
642 }
646 /* compute physical length of line in screen */
654 }
657 }
663 }
664 }
667 /* if line has been changed */
673 }
677 }
678 }
679 #if ~WFDEBUG
685 #endif
686 }
687 #if WFDEBUG
691 #endif
693 /* and onward to the next window */
695 }
697 /* Always recompute the row and column number of the hardware cursor. This
698 * is the only update for simple moves.
699 */
706 }
717 }
720 }
726 }
727 }
730 /* flag we are extended and changed */
736 /* make sure no lines need to be de-extended because the cursor is
737 * no longer on them
738 */
748 /* always flag extended lines as changed */
757 /* this line no longer is extended */
759 }
760 }
763 }
764 /* and onward to the next window */
766 }
768 /* Special hacking if the screen is garbage. Clear the hardware screen,
769 * and update your copy to agree with it. Set all the virtual screen
770 * change bits, to force a full update.
771 */
782 }
784 /*
785 * since we're using only a portion of the screen and only
786 * one buffer, only clear enough screen for the current window
787 * which is to say the *only* window.
788 */
793 }
800 }
812 }
813 }
817 }
818 }
825 else
827 }
829 /* Make sure that the physical and virtual displays agree. Unlike before,
830 * the "updateline" code is only called with a line that has been updated
831 * for sure.
832 */
835 else
840 else
847 /* for each line that needs to be updated, or that needs its
848 reverse video status changed, call the line updater */
852 #if TYPEAH
854 #ifdef _WINDOWS
856 #endif
858 }
859 #endif
863 }
864 }
874 }
877 /* TRANSLATORS: UnJustify means undo the previous
878 Justify command. */
883 }
884 }
885 else
890 }
891 }
896 }
898 /* Finally, update the hardware cursor and flush out buffers. */
901 #ifdef _WINDOWS
904 /*
905 * Update the scroll bars. This function is where curbp->b_linecnt
906 * is really managed. See update_scroll.
907 */
909 #endif
911 }
914 /* updext - update the extended line which the cursor is currently
915 * on at a column greater than the terminal width. The line
916 * will be scrolled right or left to let the user see where
917 * the cursor is
918 */
919 void
921 {
928 /*
929 * Calculate what column the real cursor will end up in.
930 * The cursor will be in the rcursor'th column. So if we're
931 * counting columns 0 1 2 3 and rcursor is 8, then rcursor
932 * will be over cell 7.
933 *
934 * What this effectively does is to scroll the screen as we're
935 * moving to the right when the cursor first passes off the
936 * screen's right edge. It would be nice if it did the same
937 * thing coming back to the left. Instead, in order that the
938 * screen's display depends only on the curcol and not on
939 * how we got there, the screen scrolls when we pass the
940 * t_margin column. It's also kind of funky that you can't
941 * see the character under the $ but you can delete it.
942 */
946 /*
947 * Make sure lbound is set so that a double-width character does
948 * not straddle the boundary. If it does, move over one cell.
949 */
954 }
960 /* scan through the line outputting characters to the virtual screen
961 * once we reach the left edge
962 */
967 /* truncate the virtual line */
970 /* and put a '$' in column 1, may have to adjust curcol */
975 /*
976 * We want to put $ in the first two columns so that it
977 * takes up the right amount of space, but that means we
978 * have to scoot the real characters over one slot.
979 */
985 }
986 }
988 /* update line color, to be executed to update lines when color is on */
989 void
991 {
1003 }
1008 /* set up pointers to virtual and physical lines */
1020 }
1030 }
1032 /* go to start of line */
1044 /*
1045 * Draw all of the characters starting with cp1
1046 * until we get to all spaces, then clear to the end of
1047 * line from there. Watch out we don't run over the
1048 * right hand edge, which shouldn't happen.
1049 *
1050 * Set cp5 to the first of the repeating spaces.
1051 */
1055 }
1057 /*
1058 * In the !nbflag case we want spaces from cp5 on.
1059 * Setting cp3 to something different from cp5 triggers
1060 * the clear to end of line below.
1061 */
1063 cleartoeol++;
1064 }
1068 /*
1069 * No peeol so draw all the way to the edge whether they
1070 * are spaces or not.
1071 */
1078 }
1081 }
1082 }
1083 }
1096 }
1097 else
1105 }
1114 }
1119 else
1130 }
1135 }
1143 }
1147 /*
1148 * Update a single line. This does not know how to use insert or delete
1149 * character sequences; we are using VT52 functionality. Update the physical
1150 * row and column variables.
1151 */
1152 void
1158 {
1170 }
1172 /* set up pointers to virtual and physical lines */
1177 /* advance past any common chars at the left */
1181 }
1183 /* This can still happen, even though we only call this routine on changed
1184 * lines. A hard update is always done when a line splits, a massive
1185 * change is done, or a buffer is displayed twice. This optimizes out most
1186 * of the excess updating. A lot of computes are used, but these tend to
1187 * be hard operations that do a lot of update, so I don't really care.
1188 */
1189 /* if both lines are the same, no update needs to be done */
1193 }
1195 /* find out if there is a match on the right */
1206 }
1216 }
1218 /* go to start of differences */
1230 }
1240 }
1241 }
1247 }
1257 }
1258 }
1259 }
1264 /*
1265 * If we need to copy characters from cp1 to cp2 and
1266 * we need to display them, then we have to worry about
1267 * the characters that we are replacing being of a different
1268 * width than the new characters, else the display may be
1269 * messed up.
1270 *
1271 * If the new width (w1) is less than the old width, that means
1272 * we will leave behind some old remnants if we aren't careful.
1273 * If the new width is larger than the old width, we have to
1274 * make sure we draw the characters all the way to the end
1275 * in order to get it right. Take advantage of clear to end
1276 * of line if we have it.
1277 */
1284 /*
1285 * Draw all of the characters starting with cp1
1286 * until we get to all spaces, then clear to the end of
1287 * line from there. Watch out we don't run over the
1288 * right hand edge, which shouldn't happen.
1289 *
1290 * Set cp5 to the first of the repeating spaces.
1291 */
1295 }
1297 /*
1298 * In the !nbflag case we want spaces from cp5 on.
1299 * Setting cp3 to something different from cp5 triggers
1300 * the clear to end of line below.
1301 */
1303 cleartoeol++;
1304 }
1308 /*
1309 * No peeol so draw all the way to the edge whether they
1310 * are spaces or not.
1311 */
1318 }
1321 }
1322 }
1323 }
1331 }
1337 }
1344 else
1347 }
1350 }
1353 /*
1354 * Redisplay the mode line for the window pointed to by the "wp". This is the
1355 * only routine that has any idea of how the modeline is formatted. You can
1356 * change the modeline format by hacking at this routine. Called by "update"
1357 * any time there is a dirty window.
1358 */
1359 void
1361 {
1380 }
1381 }
1401 }
1406 }
1407 else
1410 #define ALLOFTHEM (w1+w1_to_2+w2+w2_to_3+w3+w3_to_r)
1411 #define ALLBUTSPACE (w1+w2+w3+w3_to_r)
1422 }
1436 }
1443 /* reduce size of file */
1448 }
1449 else
1458 else
1460 }
1461 }
1462 }
1463 }
1464 }
1481 CELL c;
1489 }
1490 }
1491 }
1495 /*
1496 * Send a command to the terminal to move the hardware cursor to row "row"
1497 * and column "col". The row and column arguments are origin 0. Optimize out
1498 * random calls. Update "ttrow" and "ttcol".
1499 */
1500 void
1502 {
1507 }
1508 }
1511 /*
1512 * Erase any sense we have of the cursor's HW location...
1513 */
1514 void
1516 {
1518 }
1520 void
1522 {
1527 }
1530 /*
1531 * Erase the message line. This is a special routine because the message line
1532 * is not considered to be part of the virtual screen. It always works
1533 * immediately; the terminal buffer is flushed via a call to the flusher.
1534 */
1535 void
1537 {
1549 }
1553 }
1554 }
1558 }
1560 /* returns the chosen dictionary. If one was already chosen
1561 * return that one
1562 */
1565 {
1576 ;
1592 EXTRAKEYS menu_dictionary[] = {
1603 };
1612 /* write the prompt in utf8, and let internal functions translate it to ucs4 */
1625 }
1632 }
1634 /* just like mlreplyd, but user cannot fill a prompt */
1635 int
1637 {
1638 UCS c;
1649 }
1663 }
1667 }
1668 }
1681 }
1682 else
1689 ;
1707 }
1708 else
1717 }
1718 else
1722 km_popped++;
1724 }
1725 /* else fall through */
1731 }
1738 }
1739 else
1748 }
1751 }
1752 }
1753 }
1756 int
1758 {
1770 }
1773 /*
1774 * Ask a yes or no question in the message line. Return either TRUE, FALSE, or
1775 * ABORT. The ABORT status is returned if the user bumps out of the question
1776 * with a ^G. if d >= 0, d is the default answer returned. Otherwise there
1777 * is no default.
1778 */
1779 int
1781 {
1788 #ifdef _WINDOWS
1795 }
1796 #endif
1801 }
1834 }
1835 else
1868 }
1869 else
1878 }
1879 else
1883 km_popped++;
1885 }
1886 /* else fall through */
1892 }
1899 }
1900 else
1909 }
1912 }
1913 }
1914 }
1917 /*
1918 * Write a prompt into the message line, then read back a response. Keep
1919 * track of the physical position of the cursor. If we are in a keyboard
1920 * macro throw the prompt away, and return the remembered response. This
1921 * lets macros run at full speed. The reply is always terminated by a carriage
1922 * return. Handle erase, kill, and abort keys.
1923 */
1924 int
1926 {
1928 }
1931 int
1933 {
1935 }
1938 /*
1939 * function key mappings
1940 */
1954 };
1957 int
1959 {
1971 }
1982 }
1991 }
1994 void
1996 {
1998 }
2001 /*
2002 * mlreplyd - write the prompt to the message line along with a default
2003 * answer already typed in. Carriage return accepts the
2004 * default. answer returned in buf which also holds the initial
2005 * default, nbuf is its length, def set means use default value.
2006 * In order to be able to eliminate keys from a menu, EXTRAKEYS
2007 * always has size 10.
2008 */
2009 int
2011 {
2024 #ifdef _WINDOWS
2039 else
2047 j++;
2048 }
2049 }
2064 }
2067 }
2068 #endif
2085 }
2086 }
2087 }
2102 }
2103 }
2104 }
2106 /* set up what to watch for and return values */
2145 }
2146 else
2154 #ifdef MOUSE
2159 #endif
2160 #ifdef _WINDOWS
2162 #endif
2164 ;
2166 #ifdef MOUSE
2168 #endif
2169 #ifdef _WINDOWS
2171 #endif
2183 else
2184 b--;
2203 else
2204 b++;
2213 km_popped++;
2218 }
2219 else
2228 }
2229 else
2234 }
2245 }
2246 else
2247 b--;
2254 }
2283 #ifdef MOUSE
2285 {
2286 MOUSEPRESS mp;
2290 /* The clicked line have anything special on it? */
2300 #ifdef _WINDOWS
2305 #endif
2310 }
2311 }
2314 #endif
2318 /* look for match in extra_v */
2323 }
2329 }
2336 }
2337 }
2342 }
2350 }
2351 }
2352 }
2354 ret:
2358 }
2359 else
2370 }
2379 }
2382 void
2384 {
2387 }
2389 void
2391 {
2400 }
2403 /*
2404 * emlwrite() - write the message string to the error half of the screen
2405 * center justified. much like mlwrite (which is still used
2406 * to paint the line for prompts and such), except it center
2407 * the text.
2408 */
2409 void
2411 {
2426 /*
2427 * next, figure out where the to move the cursor so the message
2428 * comes out centered
2429 */
2452 }
2453 }
2457 else
2464 }
2465 else
2479 }
2500 }
2501 }
2502 else
2504 bufp++;
2505 }
2512 }
2513 else
2519 }
2522 int
2524 {
2534 }
2537 /*
2538 * Write a message into the message line. Keep track of the physical cursor
2539 * position. A small class of printf like format items is handled. Assumes the
2540 * stack grows down; this assumption is made by the "++" in the argument scan
2541 * loop. Set the "message line" flag TRUE.
2542 */
2543 int
2545 {
2547 UCS c;
2552 /*
2553 * the idea is to only highlight if there is something to show
2554 */
2562 }
2563 else
2571 }
2604 }
2605 }
2606 }
2617 }
2618 else
2625 }
2628 /*
2629 * Write out an integer, in the specified radix. Update the physical cursor
2630 * position. This will not handle any negative numbers; maybe it should.
2631 */
2632 void
2634 {
2641 }
2649 }
2652 /*
2653 * do the same except as a long integer.
2654 */
2655 void
2657 {
2663 }
2671 }
2674 void
2676 {
2678 EML eml;
2684 /* fall through */
2685 }
2689 }
2690 else
2733 }
2738 }
2741 /*
2742 * scrolldown - use stuff to efficiently move blocks of text on the
2743 * display, and update the pscreen array to reflect those
2744 * moves...
2745 *
2746 * wp is the window to move in
2747 * r is the row at which to begin scrolling
2748 * n is the number of lines to scrol
2749 */
2750 void
2752 {
2753 #ifdef TERMCAP
2765 }
2770 }
2778 }
2783 }
2786 /*
2787 * scrollup - use tcap stuff to efficiently move blocks of text on the
2788 * display, and update the pscreen array to reflect those
2789 * moves...
2790 */
2791 void
2793 {
2794 #ifdef TERMCAP
2812 }
2816 }
2820 i++;
2821 }
2826 }
2829 /*
2830 * print spaces in the physical screen starting from row abs(n) working in
2831 * either the positive or negative direction (depending on sign of n).
2832 */
2833 void
2835 {
2844 }
2845 }
2846 }
2852 }
2853 }
2854 }
2857 }
2860 /*
2861 * doton - return the physical line number that the dot is on in the
2862 * current window, and by side effect the number of lines remaining
2863 */
2864 int
2866 {
2879 i++;
2881 }
2884 }
2887 }
2891 /*
2892 * resize_pico - given new window dimensions, allocate new resources
2893 */
2894 int
2896 {
2913 }
2918 }
2921 else
2924 /*
2925 * free unused screen space ...
2926 */
2930 }
2932 /*
2933 * realloc new space for screen ...
2934 */
2938 else
2940 }
2945 else
2947 }
2952 else
2963 }
2967 else
2975 }
2980 }
2985 }
2986 }
2989 }
2991 void
2993 {
2996 }
2999 /*
3000 * showCompTitle - display the anchor line passed in from pine
3001 */
3002 void
3004 {
3018 }
3019 else
3025 else
3031 }
3032 else
3037 }
3038 }
3042 /*
3043 * zotdisplay - blast malloc'd space created for display maps
3044 */
3045 void
3047 {
3053 }
3057 }
3061 /*
3062 * nlforw() - returns the number of lines from the top to the dot
3063 */
3064 int
3066 {
3072 i++;
3073 }
3075 }
3079 /*
3080 * pputc - output the given char, keep track of it on the physical screen
3081 * array, and keep track of the cursor
3082 */
3083 void
3086 {
3089 /*
3090 * This is necessary but not sufficient to allow us to draw. Note that
3091 * ttrow runs from 0 to t_nrow (so total number of rows is t_nrow+1)
3092 * ttcol runs from 0 to t_ncol-1 (so total number of cols is t_ncol)
3093 */
3096 /*
3097 * Width is the number of screen columns a character will occupy.
3098 */
3100 printable_ascii++;
3102 }
3103 else
3110 /*
3111 * Some terminals scroll when you write in the lower right corner
3112 * of the screen, so don't write there.
3113 */
3119 }
3120 }
3122 /*
3123 * Character overlaps right edge of screen. Hopefully the higher
3124 * layers will prevent this but we're making sure.
3125 *
3126 * We may want to do something like writing a space character
3127 * into the cells that are on the screen. We'll see.
3128 */
3129 }
3132 }
3133 }
3136 /*
3137 * pputs - print a string and keep track of the cursor
3138 */
3139 void
3142 {
3145 }
3148 void
3150 {
3158 }
3159 }
3160 }
3163 /*
3164 * peeol - physical screen array erase to end of the line. remember to
3165 * track the cursor.
3166 */
3167 void
3169 {
3171 CELL cl;
3179 /*
3180 * Don't clear if we think we are sitting past the last column,
3181 * that erases the last column if we just wrote it.
3182 */
3186 /*
3187 * Because the characters are variable width it's a little tricky
3188 * to erase the rest of the line. What we do is add up the
3189 * widths of the characters until we reach ttcol
3190 * then set the rest to the space character.
3191 */
3195 }
3199 }
3202 /*
3203 * pscr - return the character cell on the physical screen map on the
3204 * given line, l, and offset, o.
3205 */
3206 CELL *
3208 {
3211 else
3213 }
3216 /*
3217 * pclear() - clear the physical screen from row x through row y (inclusive)
3218 * row is zero origin, min row = 0 max row = t_nrow
3219 * Clear whole screen -- pclear(0, term.t_nrow)
3220 * Clear bottom two rows -- pclear(term.t_nrow-1, term.t_nrow)
3221 * Clear bottom three rows -- pclear(term.t_nrow-2, term.t_nrow)
3222 */
3223 void
3225 {
3234 }
3235 }
3238 /*
3239 * dumbroot - just get close
3240 */
3241 int
3243 {
3246 else
3248 }
3251 /*
3252 * dumblroot - just get close
3253 */
3254 int
3256 {
3259 else
3261 }
3264 /*
3265 * pinsertc - use optimized insert, fixing physical screen map.
3266 * returns true if char written, false otherwise
3267 */
3268 int
3270 {
3291 }
3294 }
3297 /*
3298 * pdel - use optimized delete to rub out the current char and
3299 * fix the physical screen array.
3300 * returns true if optimized the delete, false otherwise
3301 */
3302 int
3304 {
3324 }
3326 /* then clean up physical screen */
3332 }
3335 }
3338 }
3342 /*
3343 * wstripe - write out the given string at the given location, and reverse
3344 * video on flagged characters. Does the same thing as pine's
3345 * stripe.
3346 *
3347 * I believe this needs to be fixed to work with non-ascii utf8pmt, but maybe
3348 * only if you want to put the tildes before multi-byte chars.
3349 */
3350 void
3352 {
3370 }
3374 }
3384 }
3387 j++;
3393 }
3397 j--;
3399 }
3403 j++;
3404 i++;
3405 }
3412 u++;
3415 else
3421 else
3423 }
3426 }
3427 }
3437 }
3439 }
3443 /*
3444 * wkeyhelp - paint list of possible commands on the bottom
3445 * of the display (yet another pine clone)
3446 * NOTE: function key mode is handled here since all the labels
3447 * are the same...
3448 *
3449 * The KEYMENU definitions have names and labels defined as UTF-8 strings,
3450 * and wstripe expects UTF-8.
3451 */
3452 void
3454 {
3458 #ifdef MOUSE
3460 #endif
3462 #ifdef _WINDOWS
3464 #endif
3472 /*
3473 * Calculate amount of space for the names column by column...
3474 */
3484 }
3485 else
3490 /*
3491 * Avoid writing in bottom right corner so we won't scroll screens that
3492 * scroll when you do that. The way this is setup, we won't do that
3493 * unless the number of columns is evenly divisible by 6.
3494 */
3506 if(keymenu[index].label[0] == '[' && keymenu[index].label[(l=strlen(keymenu[index].label))-1] == ']' && l > 2){
3510 }
3511 else
3519 }
3520 else
3522 #ifdef MOUSE
3539 #endif
3545 }
3558 }
3564 #ifdef MOUSE
3566 #endif
3567 }
3570 index++;
3571 }
3574 }
3575 }
3578 /*
3579 * This returns the screen width between pstart (inclusive) and
3580 * pend (exclusive) where the pointers point into an array of CELLs.
3581 */
3582 unsigned
3584 {
3593 }
3596 }
3599 /*
3600 * This returns the virtual screen width in row from index a to b (exclusive).
3601 */
3602 unsigned
3604 {
3622 }
3625 /*
3626 * This returns the physical screen width in row from index a to b (exclusive).
3627 */
3628 unsigned
3630 {
3648 }
3651 int
3653 {
3670 }
3671 else
3673 }
3675 /* MIN and MAX just to be sure */
3677 }
3679 #ifdef _WINDOWS
3681 void
3683 {
3686 UCS key;
3690 /* keymenu's seem to be hardcoded at 12 entries. */
3699 else
3703 }
3704 }
3705 }
3707 /*
3708 * Update the scroll range and position. (exported)
3709 *
3710 * This is where curbp->b_linecnt is really managed. With out this function
3711 * to count the number of lines when needed curbp->b_linecnt will never
3712 * really be correct. BUT, this function is only compiled into the
3713 * windows version, so b_linecnt will only ever be right in the windows
3714 * version. OK for now because that is the only version that
3715 * looks at b_linecnt.
3716 */
3717 int
3719 {
3728 /* Editing header - don't allow scroll bars. */
3731 }
3734 /*
3735 * Count the number of lines in the current buffer. Done when:
3736 *
3737 * when told to recount: curbp->b_linecnt == -1
3738 * when the top line changed: curwp->w_linep != last_top_line
3739 * when we don't know the scroll pos: last_scroll_pos == -1
3740 *
3741 * The first line in the list is a "place holder" line and is not
3742 * counted. The list is circular, when we return the to place
3743 * holder we have reached the end.
3744 */
3755 }
3760 }
3762 /*
3763 * Set new scroll range and position.
3764 */
3768 }