| blob | 0afc3586e2b455a64970888367c8c283668b90a2 |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2006-2008 University of Washington
8 * Copyright 2013-2017 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 outputing 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 {
2393 }
2396 /*
2397 * emlwrite() - write the message string to the error half of the screen
2398 * center justified. much like mlwrite (which is still used
2399 * to paint the line for prompts and such), except it center
2400 * the text.
2401 */
2402 void
2404 {
2419 /*
2420 * next, figure out where the to move the cursor so the message
2421 * comes out centered
2422 */
2445 }
2446 }
2450 else
2457 }
2458 else
2472 }
2493 }
2494 }
2495 else
2497 bufp++;
2498 }
2505 }
2506 else
2512 }
2515 int
2517 {
2527 }
2530 /*
2531 * Write a message into the message line. Keep track of the physical cursor
2532 * position. A small class of printf like format items is handled. Assumes the
2533 * stack grows down; this assumption is made by the "++" in the argument scan
2534 * loop. Set the "message line" flag TRUE.
2535 */
2536 int
2538 {
2540 UCS c;
2545 /*
2546 * the idea is to only highlight if there is something to show
2547 */
2555 }
2556 else
2564 }
2597 }
2598 }
2599 }
2610 }
2611 else
2618 }
2621 /*
2622 * Write out an integer, in the specified radix. Update the physical cursor
2623 * position. This will not handle any negative numbers; maybe it should.
2624 */
2625 void
2627 {
2634 }
2642 }
2645 /*
2646 * do the same except as a long integer.
2647 */
2648 void
2650 {
2656 }
2664 }
2667 void
2669 {
2671 EML eml;
2677 /* fall through */
2678 }
2682 }
2683 else
2726 }
2731 }
2734 /*
2735 * scrolldown - use stuff to efficiently move blocks of text on the
2736 * display, and update the pscreen array to reflect those
2737 * moves...
2738 *
2739 * wp is the window to move in
2740 * r is the row at which to begin scrolling
2741 * n is the number of lines to scrol
2742 */
2743 void
2745 {
2746 #ifdef TERMCAP
2758 }
2763 }
2771 }
2776 }
2779 /*
2780 * scrollup - use tcap stuff to efficiently move blocks of text on the
2781 * display, and update the pscreen array to reflect those
2782 * moves...
2783 */
2784 void
2786 {
2787 #ifdef TERMCAP
2805 }
2809 }
2813 i++;
2814 }
2819 }
2822 /*
2823 * print spaces in the physical screen starting from row abs(n) working in
2824 * either the positive or negative direction (depending on sign of n).
2825 */
2826 void
2828 {
2837 }
2838 }
2839 }
2845 }
2846 }
2847 }
2850 }
2853 /*
2854 * doton - return the physical line number that the dot is on in the
2855 * current window, and by side effect the number of lines remaining
2856 */
2857 int
2859 {
2872 i++;
2874 }
2877 }
2880 }
2884 /*
2885 * resize_pico - given new window dimensions, allocate new resources
2886 */
2887 int
2889 {
2906 }
2911 }
2914 else
2917 /*
2918 * free unused screen space ...
2919 */
2923 }
2925 /*
2926 * realloc new space for screen ...
2927 */
2931 else
2933 }
2938 else
2940 }
2945 else
2956 }
2960 else
2968 }
2973 }
2978 }
2979 }
2982 }
2984 void
2986 {
2989 }
2992 /*
2993 * showCompTitle - display the anchor line passed in from pine
2994 */
2995 void
2997 {
3011 }
3012 else
3018 else
3024 }
3025 else
3030 }
3031 }
3035 /*
3036 * zotdisplay - blast malloc'd space created for display maps
3037 */
3038 void
3040 {
3046 }
3050 }
3054 /*
3055 * nlforw() - returns the number of lines from the top to the dot
3056 */
3057 int
3059 {
3065 i++;
3066 }
3068 }
3072 /*
3073 * pputc - output the given char, keep track of it on the physical screen
3074 * array, and keep track of the cursor
3075 */
3076 void
3079 {
3082 /*
3083 * This is necessary but not sufficient to allow us to draw. Note that
3084 * ttrow runs from 0 to t_nrow (so total number of rows is t_nrow+1)
3085 * ttcol runs from 0 to t_ncol-1 (so total number of cols is t_ncol)
3086 */
3089 /*
3090 * Width is the number of screen columns a character will occupy.
3091 */
3093 printable_ascii++;
3095 }
3096 else
3103 /*
3104 * Some terminals scroll when you write in the lower right corner
3105 * of the screen, so don't write there.
3106 */
3112 }
3113 }
3115 /*
3116 * Character overlaps right edge of screen. Hopefully the higher
3117 * layers will prevent this but we're making sure.
3118 *
3119 * We may want to do something like writing a space character
3120 * into the cells that are on the screen. We'll see.
3121 */
3122 }
3125 }
3126 }
3129 /*
3130 * pputs - print a string and keep track of the cursor
3131 */
3132 void
3135 {
3138 }
3141 void
3143 {
3151 }
3152 }
3153 }
3156 /*
3157 * peeol - physical screen array erase to end of the line. remember to
3158 * track the cursor.
3159 */
3160 void
3162 {
3164 CELL cl;
3172 /*
3173 * Don't clear if we think we are sitting past the last column,
3174 * that erases the last column if we just wrote it.
3175 */
3179 /*
3180 * Because the characters are variable width it's a little tricky
3181 * to erase the rest of the line. What we do is add up the
3182 * widths of the characters until we reach ttcol
3183 * then set the rest to the space character.
3184 */
3188 }
3192 }
3195 /*
3196 * pscr - return the character cell on the physical screen map on the
3197 * given line, l, and offset, o.
3198 */
3199 CELL *
3201 {
3204 else
3206 }
3209 /*
3210 * pclear() - clear the physical screen from row x through row y (inclusive)
3211 * row is zero origin, min row = 0 max row = t_nrow
3212 * Clear whole screen -- pclear(0, term.t_nrow)
3213 * Clear bottom two rows -- pclear(term.t_nrow-1, term.t_nrow)
3214 * Clear bottom three rows -- pclear(term.t_nrow-2, term.t_nrow)
3215 */
3216 void
3218 {
3227 }
3228 }
3231 /*
3232 * dumbroot - just get close
3233 */
3234 int
3236 {
3239 else
3241 }
3244 /*
3245 * dumblroot - just get close
3246 */
3247 int
3249 {
3252 else
3254 }
3257 /*
3258 * pinsertc - use optimized insert, fixing physical screen map.
3259 * returns true if char written, false otherwise
3260 */
3261 int
3263 {
3284 }
3287 }
3290 /*
3291 * pdel - use optimized delete to rub out the current char and
3292 * fix the physical screen array.
3293 * returns true if optimized the delete, false otherwise
3294 */
3295 int
3297 {
3317 }
3319 /* then clean up physical screen */
3325 }
3328 }
3331 }
3335 /*
3336 * wstripe - write out the given string at the given location, and reverse
3337 * video on flagged characters. Does the same thing as pine's
3338 * stripe.
3339 *
3340 * I believe this needs to be fixed to work with non-ascii utf8pmt, but maybe
3341 * only if you want to put the tildes before multi-byte chars.
3342 */
3343 void
3345 {
3363 }
3367 }
3377 j++;
3384 j--;
3386 }
3390 j++;
3391 i++;
3392 }
3399 u++;
3402 else
3408 else
3410 }
3413 }
3414 }
3424 }
3426 }
3430 /*
3431 * wkeyhelp - paint list of possible commands on the bottom
3432 * of the display (yet another pine clone)
3433 * NOTE: function key mode is handled here since all the labels
3434 * are the same...
3435 *
3436 * The KEYMENU definitions have names and labels defined as UTF-8 strings,
3437 * and wstripe expects UTF-8.
3438 */
3439 void
3441 {
3445 #ifdef MOUSE
3447 #endif
3449 #ifdef _WINDOWS
3451 #endif
3459 /*
3460 * Calculate amount of space for the names column by column...
3461 */
3471 }
3472 else
3477 /*
3478 * Avoid writing in bottom right corner so we won't scroll screens that
3479 * scroll when you do that. The way this is setup, we won't do that
3480 * unless the number of columns is evenly divisible by 6.
3481 */
3493 if(keymenu[index].label[0] == '[' && keymenu[index].label[(l=strlen(keymenu[index].label))-1] == ']' && l > 2){
3497 }
3498 else
3506 }
3507 else
3509 #ifdef MOUSE
3526 #endif
3532 }
3545 }
3551 #ifdef MOUSE
3553 #endif
3554 }
3557 index++;
3558 }
3561 }
3562 }
3565 /*
3566 * This returns the screen width between pstart (inclusive) and
3567 * pend (exclusive) where the pointers point into an array of CELLs.
3568 */
3569 unsigned
3571 {
3580 }
3583 }
3586 /*
3587 * This returns the virtual screen width in row from index a to b (exclusive).
3588 */
3589 unsigned
3591 {
3609 }
3612 /*
3613 * This returns the physical screen width in row from index a to b (exclusive).
3614 */
3615 unsigned
3617 {
3635 }
3638 int
3640 {
3657 }
3658 else
3660 }
3662 /* MIN and MAX just to be sure */
3664 }
3666 #ifdef _WINDOWS
3668 void
3670 {
3673 UCS key;
3677 /* keymenu's seem to be hardcoded at 12 entries. */
3686 else
3690 }
3691 }
3692 }
3694 /*
3695 * Update the scroll range and position. (exported)
3696 *
3697 * This is where curbp->b_linecnt is really managed. With out this function
3698 * to count the number of lines when needed curbp->b_linecnt will never
3699 * really be correct. BUT, this function is only compiled into the
3700 * windows version, so b_linecnt will only ever be right in the windows
3701 * version. OK for now because that is the only version that
3702 * looks at b_linecnt.
3703 */
3704 int
3706 {
3715 /* Editing header - don't allow scroll bars. */
3718 }
3721 /*
3722 * Count the number of lines in the current bufer. Done when:
3723 *
3724 * when told to recount: curbp->b_linecnt == -1
3725 * when the top line changed: curwp->w_linep != last_top_line
3726 * when we don't know the scroll pos: last_scroll_pos == -1
3727 *
3728 * The first line in the list is a "place holder" line and is not
3729 * counted. The list is circular, when we return the to place
3730 * holder we have reached the end.
3731 */
3742 }
3747 }
3749 /*
3750 * Set new scroll range and position.
3751 */
3755 }