| blob | 5c538de14ac623184a7783002a29d4f31f4e9fc0 |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2006-2009 University of Washington
8 * Copyright 2013-2021 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: Pine composer routines
19 *
20 * NOTES:
21 *
22 * - composer.c is the composer for the PINE mail system
23 *
24 * - tabled 01/19/90
25 *
26 * Notes: These routines aren't incorporated yet, because the composer as
27 * a whole still needs development. These are ideas that should
28 * be implemented in later releases of PINE. See the notes in
29 * pico.c concerning what needs to be done ....
30 *
31 * - untabled 01/30/90
32 *
33 * Notes: Installed header line editing, with wrapping and unwrapping,
34 * context sensitive help, and other mail header editing features.
35 *
36 * - finalish code cleanup 07/15/91
37 *
38 * Notes: Killed/yanked header lines use emacs kill buffer.
39 * Arbitrarily large headers are handled gracefully.
40 * All formatting handled by FormatLines.
41 *
42 * - Work done to optimize display painting 06/26/92
43 * Not as clean as it should be, needs more thought
44 *
45 */
85 /*
86 * definition header field array, structures defined in pico.h
87 */
91 /*
92 * structure that keeps track of the range of header lines that are
93 * to be displayed and other fun stuff about the header
94 */
97 /* a pointer to the subject line. This is so that we do not have to compute
98 * the header line in every call. It saves a few CPU cycles
99 */
103 /*
104 * useful macros
105 */
106 #define HALLOC() (struct hdr_line *)malloc(sizeof(struct hdr_line))
107 #define LINEWID() (((term.t_ncol - headents[ods.cur_e].prwid) > 0) ? ((unsigned) (term.t_ncol - headents[ods.cur_e].prwid)) : 0)
108 #define BOTTOM() (term.t_nrow - term.t_mrow)
109 #define FULL_SCR() (BOTTOM() - 3)
110 #define HALF_SCR() (FULL_SCR()/2)
112 #ifdef MOUSE
113 /*
114 * Redefine HeaderEditor to install wrapper required for mouse event
115 * handling...
116 */
117 #define HeaderEditor HeaderEditorWork
122 /*
123 * useful declarations
124 */
130 /* TRANSLATORS: command key labels, Send means send the message
131 we are currently working on. */
133 /* TRANSLATORS: Rich Headers is a command to display more headers. It
134 is triggered with the ^R key. PrvPg stands for Previous Page. */
136 /* TRANSLATORS: Cut Line means remove a line. Postpone means to save
137 a message being composed so that it can be worked on later. */
139 /* TRANSLATORS: Del Char is Delete Character */
141 /* TRANSLATORS: Next Page */
143 /* TRANSLATORS: Undelete a line that was just deleted */
145 };
146 #define SEND_KEY 1
147 #define RICH_KEY 2
148 #define CUT_KEY 4
149 #define PONE_KEY 5
150 #define DEL_KEY 7
151 #define ATT_KEY 8
152 #define UDEL_KEY 10
153 #define TO_KEY 11
156 /*
157 * function key mappings for header editor
158 */
172 };
175 /*
176 * InitMailHeader - initialize header array, and set beginning editor row
177 * range. The header entry structure should look just like
178 * what is written on the screen, the vector
179 * (entry, line, offset) will describe the current cursor
180 * position in the header.
181 *
182 * Returns: TRUE if special header handling was requested,
183 * FALSE under standard default behavior.
184 */
185 int
187 {
195 }
197 /*
198 * initialize some of on_display structure, others below...
199 */
205 /*--- initialize the fields in the headerent structure ----*/
210 /*--- A lot of work to do since attachments are special ---*/
228 }
232 }
237 ofp1,
244 /* append description, escaping quotes */
249 do
252 ofp2--;
253 }
257 }
261 }
271 }
272 }
276 }
278 }
283 }
288 else
292 }
293 }
295 /*
296 * finish initialization and then figure out display layout.
297 * first, look for any field the caller requested we start in,
298 * and set the offset into that field.
299 */
307 }
313 }
317 }
321 /*
322 * InitEntryText - Add the given header text into the header entry
323 * line structure.
324 */
325 int
327 {
331 /*
332 * get first chunk of memory, and tie it to structure...
333 */
337 }
347 else
349 }
353 /*
354 * ResizeHeader - Handle resizing display when SIGWINCH received.
355 *
356 * notes:
357 * works OK, but needs thorough testing
358 *
359 */
360 int
362 {
375 }
376 }
385 i--;
394 }
397 }
409 }
413 /*
414 * HeaderOffset - return the character offset into the given header
415 */
416 int
418 {
427 }
429 }
433 /*
434 * HeaderFocus - put the dot at the given offset into the given header
435 */
436 int
438 {
450 }
454 else
456 }
459 }
466 }
470 /*
471 * HeaderEditor() - edit the mail header field by field, trapping
472 * important key sequences, hand the hard work off
473 * to LineEdit().
474 * returns:
475 * -3 if we drop out bottom *and* want to process mouse event
476 * -1 if we drop out the bottom
477 * FALSE if editing is cancelled
478 * TRUE if editing is finished
479 */
480 int
482 {
490 #ifdef MOUSE
491 MOUSEPRESS mp;
492 #endif
500 #ifdef _WINDOWS
509 /*
510 * Decide where to begin editing. if f == TRUE begin editing
511 * at the bottom. this case results from the cursor backing
512 * into the editor from the bottom. otherwise, the user explicitly
513 * requested editing the header, and we begin at the top.
514 *
515 * further, if f == 1, we moved into the header by hitting the up arrow
516 * in the message text, else if f == 2, we moved into the header by
517 * moving past the left edge of the top line in the message. so, make
518 * the end of the last line of the last entry the current cursor position
519 * lastly, if f == 3, we moved into the header by hitting backpage() on
520 * the top line of the message, so scroll a page back.
521 */
527 /*--- make sure on last field ---*/
532 }
535 }
537 /*
538 * note: assumes that ods.cur_e and ods.cur_l haven't changed
539 * since we left...
540 */
542 /* fix position */
547 else
550 /* and scroll back if needed */
553 ;
554 }
557 }
558 /* else just trust what ods contains */
566 km_popped--;
569 }
577 }
586 }
587 }
595 km_popped++;
606 }
616 }
617 else
619 }
621 /*---- Are there any headers to expand above us? ---*/
631 /*--- Just turned off all rich headers --*/
633 /*-- current header got turned off too --*/
634 #ifdef ATTACHMENTS
636 /* verify the attachments */
641 }
642 }
643 #endif
646 /* Check below */
651 /* didn't find one, check above */
653 cur_e--)
657 }
661 }
662 }
679 #ifdef ATTACHMENTS
681 /* verify the attachments, and pretty things up in case
682 * we come back to the composer due to error...
683 */
689 }
690 }
691 else
692 #endif
701 }
708 }
716 /*
717 * need to be careful here because pointers might be messed up.
718 * also, could do a better job of finding the right place to
719 * put the dot back (i.e., the addr/list that was expanded).
720 */
724 }
731 }
732 else
738 #if defined MOUSE && !defined(_WINDOWS)
740 #else
742 #endif
764 }
765 }
766 }
778 #ifdef ATTACHMENTS
789 /*
790 * Attachment questions mess with km_popped and assume
791 * it is zero to start with. If we don't set it to zero
792 * on entry, the message about mime type will be erased
793 * by PaintBody. If we don't reset it when we come back,
794 * the bottom three lines may be messed up.
795 */
812 NULL);
814 }
815 }
819 }
824 else
833 }
836 }
840 }
842 #endif
864 && (*start
873 start--;
876 start++;
879 add_a_comma++;
881 /*
882 * Nickname prefix begins with start and ends
883 * with end-1. Replace those characters with
884 * completed nickname.
885 */
893 /*
894 * Ambiguity == 0 means no matches exist.
895 * 1 means it is ambiguous and the longest
896 * unambiguous prefix beginning with prefix
897 * is in new_nickname.
898 * 2 means it is unambiguous and the answer
899 * is in new_nickname
900 *
901 * The expansion from == 2 doesn't have to have prefix
902 * as a prefix. For example, if the prefix is a prefix
903 * of the full name or a prefix of a nickname the answer
904 * might be the full address instead of the expanded
905 * prefix. In fact, that's probably the expected thing.
906 *
907 * Due to the way the build_abook_tries sets up the tries
908 * it is unfortunately the case that the expanded address
909 * is not entered in any trie, so after you get an
910 * unambiguous expansion if you try TAB again at that
911 * point you'll probably get a no match returned instead
912 * of an unambiguous. So be aware of that and handle
913 * that case ok by falling through to header_downline.
914 */
918 /*
919 * Don't fall through on no-match TAB unless
920 * it is the second TAB.
921 */
925 }
935 /*
936 * We're trying to work with the way
937 * FormatLines works. It inserts text at the
938 * beginning of the line we pass in.
939 * So, remove the beginning of the line and
940 * have FormatLines put it back.
941 */
943 /* save part before start */
951 /* figure out new cursor offset */
956 }
960 /*
961 * Delete everything up to end by
962 * copying characters to start of buffer.
963 */
976 /* add a comma? */
978 l++;
979 offset++;
980 }
981 else
986 /*
987 * Insert is the before start stuff plus the
988 * new nickname, and we're going to let
989 * FormatLines put it together for us.
990 */
998 }
1001 }
1008 }
1014 }
1017 }
1021 }
1026 }
1042 }
1055 }
1058 }
1061 }
1063 nomore_to_complete:
1065 }
1084 }
1093 /*
1094 * Count down move_down lines to find the pointer to the line
1095 * that we want to become the current line.
1096 */
1105 }
1113 }
1115 /*
1116 * Now call header_downline until we get down to the
1117 * new current line, so that the builders all get called.
1118 * New_cur_l will remain valid since we won't be calling
1119 * a builder for it during this loop.
1120 */
1122 ;
1124 /*
1125 * Count back up, if we're at the bottom, to find the new
1126 * top line.
1127 */
1130 /*
1131 * Cursor stops at bottom of headers, which is where
1132 * we are right now. Put as much of headers on
1133 * screen as will fit. Count up to figure
1134 * out which line is top_l and which p_line cursor is on.
1135 */
1138 /* leave delimiter on screen, too */
1146 }
1152 }
1156 /*
1157 * We don't want to scroll down further than the
1158 * delimiter, so check to see if that is the case.
1159 * If it is, we move the p_line down the screen
1160 * until the bottom line is where we want it.
1161 */
1171 }
1173 /*
1174 * i is the desired value of p_line.
1175 * If it is greater than COMPOSER_TOP_LINE, then
1176 * we need to adjust top_l.
1177 */
1187 }
1192 /*
1193 * Special case. If p_line is within one of the bottom,
1194 * move it to the bottom.
1195 */
1198 /* but put these back where we want them */
1202 }
1203 }
1208 }
1220 #ifdef MOUSE
1230 ;
1231 }
1236 ;
1237 }
1242 /* -3 is returned if we drop out bottom
1243 * *and* want to process a mousepress. The Headereditor
1244 * wrapper should make sense of this return code.
1245 */
1248 }
1253 #ifdef _WINDOWS
1255 #endif
1259 }
1267 /*--- selector for attachments ----*/
1274 ? opertree
1297 NULL);
1299 }
1300 }
1304 }
1309 else
1321 }
1327 }
1334 /*---- General selector for non-attachments -----*/
1336 /*
1337 * Since the selector may make a new call back to pico()
1338 * we need to save and restore the pico state here.
1339 */
1346 }
1356 }
1362 /*--- Must be an address ---*/
1364 /*
1365 * If current line is empty and there are more
1366 * lines that follow, delete the empty lines
1367 * before adding the new address.
1368 */
1374 }
1382 /* cur is not first line */
1384 /*
1385 * Protect against adding a new entry into
1386 * the middle of a long, continued entry.
1387 */
1394 }
1400 }
1405 }
1406 }
1412 }
1418 NULL);
1421 }
1423 /*
1424 * If the "selector" has a "builder" as well, pass
1425 * what was just selected thru the builder...
1426 */
1434 ;
1442 }
1447 ;
1451 }
1462 }
1463 }
1466 /* mark this entry dirty */
1470 }
1472 /*----- No selector -----*/
1475 }
1483 }
1492 }
1493 }
1510 /*
1511 * Since the fileedit will make a new call back to pico()
1512 * we need to save and restore the pico state here.
1513 */
1530 }
1541 }
1550 }
1559 }
1562 }
1563 else
1569 bleep:
1574 }
1575 }
1586 }
1589 }
1592 /*
1593 *
1594 */
1595 int
1597 {
1601 /* calculate the next line: physical *and* logical */
1622 }
1625 }
1627 /*
1628 * Because of blank header lines the cursor may need to move down
1629 * more than one line. Figure out how far.
1630 */
1635 incr++;
1636 else
1638 }
1643 /* expand what needs expanding */
1655 }
1670 }
1676 }
1679 }
1684 }
1685 }
1692 }
1702 }
1703 }
1706 }
1709 /*
1710 *
1711 */
1712 int
1714 {
1717 EML eml;
1719 /* calculate the next line: physical *and* logical */
1727 }
1730 }
1732 /*
1733 * Because of blank header lines the cursor may need to move up
1734 * more than one line. Figure out how far.
1735 */
1740 incr++;
1741 else
1743 }
1757 }
1758 }
1765 /* repair new_l */
1769 ;
1771 /* and cur_l (required in fix_and... */
1773 }
1779 }
1782 }
1786 }
1797 }
1800 }
1803 /*
1804 *
1805 */
1806 int
1808 {
1814 /*--- Find headerentry that is attachments (only first) --*/
1817 /* make sure field stays displayed */
1821 }
1823 /* append new attachment line */
1825 ;
1827 /* build new attachment line */
1838 }
1842 }
1843 }
1855 }
1857 /* validate the new attachment, and reformat if needed */
1859 EML eml;
1864 }
1871 }
1872 }
1878 }
1881 /*
1882 * LineEdit - Always use insert mode and handle line wrapping
1883 *
1884 * returns:
1885 * Any characters typed in that aren't printable
1886 * (i.e. commands)
1887 *
1888 * notes:
1889 * Assume we are guaranteed that there is sufficiently
1890 * more buffer space in a line than screen width (just one
1891 * less thing to worry about). If you want to change this,
1892 * then pputc will have to be taught to check the line buffer
1893 * length, and HALLOC() will probably have to become a func.
1894 */
1895 UCS
1897 {
1918 }
1929 else
1938 #ifdef MOUSE
1942 #endif
1943 #ifdef _WINDOWS
1946 #endif
1954 }
1956 #ifdef MOUSE
1958 #endif
1959 #ifdef _WINDOWS
1962 #endif
1981 }
1995 }
1996 }
2005 }
2012 }
2013 }
2018 /*
2019 * if we are allowing editing, insert the new char
2020 * end up leaving tbufp pointing to newly
2021 * inserted character in string, and offset to the
2022 * index of the character after the inserted ch ...
2023 */
2028 }
2034 }
2036 /*
2037 * go ahead and add the character...
2038 */
2045 }
2047 /* mark this entry dirty */
2051 /*
2052 * then find out where things fit...
2053 */
2055 CELL c;
2062 }
2063 }
2069 }
2071 /*
2072 * during the format, the dot may have moved
2073 * down to the next line...
2074 */
2080 }
2083 }
2089 }
2090 }
2094 }
2095 }
2103 {
2107 }
2113 /* Bail if the character right before this one is whitespace */
2117 }
2131 }
2139 }
2154 }
2161 km_popped--;
2164 }
2168 }
2179 }
2185 km_popped--;
2188 }
2195 }
2196 else
2197 /* TRANSLATORS: Killing text is deleting it and
2198 Unkilling text is undeleting killed text. */
2207 }
2219 }
2243 }
2250 }
2259 }
2264 }
2271 else
2280 }
2285 }
2293 }
2297 }
2300 }
2306 }
2308 /*
2309 * beware, the dot may have moved...
2310 */
2319 }
2327 }
2339 }
2340 }
2347 }
2348 }
2351 void
2353 {
2354 movecursor(ods.p_line, ucs4_str_width_ptr_to_ptr(&ods.cur_l->text[0], &ods.cur_l->text[ods.p_ind])+headents[ods.cur_e].prwid);
2355 }
2359 /*
2360 * FormatLines - Place the given text at the front of the given line->text
2361 * making sure to properly format the line, then check
2362 * all lines below for proper format.
2363 *
2364 * notes:
2365 * Not much optimization at all. Right now, it recursively
2366 * fixes all remaining lines in the entry. Some speed might
2367 * gained if this was built to iteratively scan the lines.
2368 *
2369 * returns:
2370 * -1 on error
2371 * FALSE if only this line is changed
2372 * TRUE if text below the first line is changed
2373 */
2374 int
2380 {
2403 }
2412 ;
2424 }
2434 }
2440 }
2442 /*
2443 * Break at maxwid - width of istr
2444 */
2447 }
2448 }
2449 else
2458 }
2462 /*
2463 * shift ostr i chars
2464 */
2469 }
2470 }
2471 }
2472 }
2473 /*
2474 * Short-circuit the recursion in this case.
2475 * No time right now to figure out how to do it better.
2476 */
2491 }
2497 }
2513 }
2524 }
2526 /*
2527 * Now l is still > maxwid. Do it the recursive way,
2528 * like the else clause below. Surely we could fix up the
2529 * flow control some here, but this works for now.
2530 */
2538 }
2545 }
2551 }
2562 }
2569 }
2575 }
2586 }
2596 }
2607 }
2608 }
2620 }
2639 }
2650 }
2651 }
2662 ;
2667 }
2668 else
2670 }
2671 else
2682 }
2683 }
2699 }
2700 else
2702 }
2703 }
2704 }
2711 }
2713 }
2733 }
2736 }
2739 }
2740 else
2742 }
2744 /*
2745 * Format the lines before parsing attachments so we
2746 * don't expand a bunch of attachments that we don't
2747 * have the buffer space for.
2748 */
2749 int
2751 {
2756 }
2759 /*
2760 * PaintHeader - do the work of displaying the header from the given
2761 * physical screen line the end of the header.
2762 *
2763 * 17 July 91 - fixed reshow to deal with arbitrarily large headers.
2764 */
2765 void
2768 {
2781 }
2792 }
2804 }
2805 }
2811 }
2817 }
2830 }
2840 }
2841 }
2846 }
2847 curline++;
2853 }
2862 }
2863 }
2870 }
2871 }
2875 /*
2876 * PaintBody() - generic call to handle repainting everything BUT the
2877 * header
2878 *
2879 * notes:
2880 * The header redrawing in a level 0 body paint gets done
2881 * in update()
2882 */
2883 void
2885 {
2895 }
2896 }
2899 /*
2900 * display_for_send - paint the composer from the top line and return.
2901 */
2902 void
2904 {
2908 /* if first header line isn't displayed, there's work to do */
2916 /*
2917 * fake that the cursor's in the first header line
2918 * and force repaint...
2919 */
2939 /* in case we don't exit, set up restoring the screen */
2941 }
2942 }
2945 /*
2946 * ArrangeHeader - set up display parm such that header is reasonably
2947 * displayed
2948 */
2949 void
2951 {
2962 }
2965 }
2968 /*
2969 * ComposerHelp() - display mail help in a context sensitive way
2970 * based on the level passed ...
2971 */
2972 int
2974 {
2986 }
2997 }
3002 }
3006 /*
3007 * ToggleHeader() - set or unset pico values to the full screen size
3008 * painting header if need be.
3009 */
3010 int
3012 {
3013 /*
3014 * check to see if we need to display the header...
3015 */
3019 }
3021 /*
3022 * set bounds for no header display
3023 */
3026 }
3028 }
3032 /*
3033 * HeaderLen() - return the length in lines of the exposed portion of the
3034 * header
3035 */
3036 int
3038 {
3048 i++;
3049 }
3051 }
3055 /*
3056 * first_hline() - return a pointer to the first displayable header line
3057 *
3058 * returns:
3059 * 1) pointer to first displayable line in header and header
3060 * entry, via side effect, that the first line is a part of
3061 * 2) NULL if no next line, leaving entry at LASTHDR
3062 */
3065 {
3066 /* init *entry so we're sure to start from the top */
3073 }
3076 /*
3077 * first_sel_hline() - return a pointer to the first selectable header line
3078 *
3079 * returns:
3080 * 1) pointer to first selectable line in header and header
3081 * entry, via side effect, that the first line is a part of
3082 * 2) NULL if no next line, leaving entry at LASTHDR
3083 */
3086 {
3087 /* init *entry so we're sure to start from the top */
3094 }
3098 /*
3099 * next_hline() - return a pointer to the next line structure
3100 *
3101 * returns:
3102 * 1) pointer to next displayable line in header and header
3103 * entry, via side effect, that the next line is a part of
3104 * 2) NULL if no next line, leaving entry at LASTHDR
3105 */
3108 {
3116 }
3119 }
3120 else
3122 }
3125 /*
3126 * next_sel_hline() - return a pointer to the next selectable line structure
3127 *
3128 * returns:
3129 * 1) pointer to next selectable line in header and header
3130 * entry, via side effect, that the next line is a part of
3131 * 2) NULL if no next line, leaving entry at LASTHDR
3132 */
3135 {
3143 }
3146 }
3147 else
3149 }
3153 /*
3154 * prev_hline() - return a pointer to the next line structure back
3155 *
3156 * returns:
3157 * 1) pointer to previous displayable line in header and
3158 * the header entry that the next line is a part of
3159 * via side effect
3160 * 2) NULL if no next line, leaving entry unchanged from
3161 * the value it had on entry.
3162 */
3165 {
3179 }
3180 }
3184 }
3185 else
3187 }
3190 /*
3191 * prev_sel_hline() - return a pointer to the previous selectable line
3192 *
3193 * returns:
3194 * 1) pointer to previous selectable line in header and
3195 * the header entry that the next line is a part of
3196 * via side effect
3197 * 2) NULL if no next line, leaving entry unchanged from
3198 * the value it had on entry.
3199 */
3202 {
3216 }
3217 }
3221 }
3222 else
3224 }
3228 /*
3229 * first_requested_hline() - return pointer to first line that pico's caller
3230 * asked that we start on.
3231 */
3234 {
3245 }
3246 }
3249 }
3253 /*
3254 * UpdateHeader() - determines the best range of lines to be displayed
3255 * using the global ods value for the current line and the
3256 * top line, also sets ComposerTopLine and pico limits
3257 *
3258 * showtop -- Attempt to show all header lines if they'll fit.
3259 *
3260 * notes:
3261 * This is pretty ugly because it has to keep the current line
3262 * on the screen in a reasonable location no matter what.
3263 * There are also a couple of rules to follow:
3264 * 1) follow paging conventions of pico (ie, half page
3265 * scroll)
3266 * 2) if more than one page, always display last half when
3267 * pline is toward the end of the header
3268 *
3269 * returns:
3270 * TRUE if anything changed (side effects: new p_line, top_l
3271 * top_e, and pico parms)
3272 * FALSE if nothing changed
3273 *
3274 */
3275 int
3277 {
3286 /* NewTop if cur header line is at bottom of screen or two from */
3287 /* the bottom of the screen if cur line is bottom header line */
3290 }
3296 /*
3297 * this checks to make sure cur_l is below top_l and that
3298 * cur_l is on the screen...
3299 */
3304 }
3305 }
3306 }
3314 }
3323 }
3332 }
3334 }
3338 /*
3339 * NewTop() - calculate a new top_l based on the cur_l
3340 *
3341 * showtop -- Attempt to show all the header lines if they'll fit
3342 *
3343 * returns:
3344 * with ods.top_l and top_e pointing at a reasonable line
3345 * entry
3346 */
3347 void
3349 {
3362 }
3363 }
3367 /*
3368 * display_delimiter() - just paint the header/message body delimiter with
3369 * inverse value specified by state.
3370 */
3371 void
3373 {
3383 }
3392 for(delim_ps = 0; bufp[delim_ps] && pscr(ComposerTopLine-1,delim_ps) != NULL && pscr(ComposerTopLine-1,delim_ps)->c == bufp[delim_ps];delim_ps++)
3393 ;
3400 }
3401 }
3423 }
3424 }
3428 /*
3429 * InvertPrompt() - invert the prompt associated with header entry to state
3430 * state (true if invert, false otherwise).
3431 * returns:
3432 * non-zero if nothing done
3433 * 0 if prompt inverted successfully
3434 *
3435 * notes:
3436 * come to think of it, this func and the one above could
3437 * easily be combined
3438 */
3439 int
3441 {
3454 }
3458 /*
3459 * Makes sure that the prompt doesn't take up more than prwid of screen space.
3460 * The caller should do that, too, in order to make it look right so
3461 * this should most likely be a no-op
3462 */
3466 }
3473 ;
3478 else
3483 }
3484 }
3489 else
3491 }
3510 }
3514 /*
3515 * partial_entries() - toggle display of the bcc and fcc fields.
3516 *
3517 * returns:
3518 * TRUE if there are partial entries on the display
3519 * FALSE otherwise.
3520 */
3521 int
3523 {
3527 /*---- find out status of first rich header ---*/
3529 ;
3537 }
3541 /*
3542 * entry_line() - return the physical line on the screen associated
3543 * with the given header entry field. Note: the field
3544 * may span lines, so if the last char is set, return
3545 * the appropriate value.
3546 *
3547 * returns:
3548 * 1) physical line number of entry
3549 * 2) -1 if entry currently not on display
3550 */
3551 int
3553 {
3560 p_line++){
3567 }
3570 else
3572 }
3574 }
3576 }
3580 /*
3581 * physical_line() - return the physical line on the screen associated
3582 * with the given header line pointer.
3583 *
3584 * returns:
3585 * 1) physical line number of entry
3586 * 2) -1 if entry currently not on display
3587 */
3588 int
3590 {
3603 }
3605 }
3609 /*
3610 * call_builder() - resolve any nicknames in the address book associated
3611 * with the given entry...
3612 *
3613 * NOTES:
3614 *
3615 * BEWARE: this function can cause cur_l and top_l to get lost so BE
3616 * CAREFUL before and after you call this function!!!
3617 *
3618 * There could to be something here to resolve cur_l and top_l
3619 * reasonably into the new linked list for this entry.
3620 *
3621 * The reason this would mostly work without it is resolve_niks gets
3622 * called for the most part in between fields. Since we're moving
3623 * to the beginning or end (i.e. the next/prev pointer in the old
3624 * freed cur_l is NULL) of the next entry, we get a new cur_l
3625 * pointing at a good line. Then since top_l is based on cur_l in
3626 * NewTop() we have pretty much lucked out.
3627 *
3628 * Where we could get burned is in a canceled exit (ctrl|x). Here
3629 * nicknames get resolved into addresses, which invalidates cur_l
3630 * and top_l. Since we don't actually leave, we could begin editing
3631 * again with bad pointers. This would usually results in a nice
3632 * core dump.
3633 *
3634 * NOTE: The mangled argument is a little strange. It's used on both
3635 * input and output. On input, if it is not set, then that tells the
3636 * builder not to do anything that might take a long time, like a
3637 * white pages lookup. On return, it tells the caller that the screen
3638 * and signals may have been mangled so signals should be reset, window
3639 * resized, and screen redrawn.
3640 *
3641 * RETURNS:
3642 * > 0 if any names where resolved, otherwise
3643 * 0 if not, or
3644 * < 0 on error
3645 * -1: move to next line
3646 * -2: don't move off this line
3647 */
3648 int
3650 {
3671 }
3672 sbuflen++;
3676 }
3680 /*
3681 * cat the whole entry into one string...
3682 */
3687 /*
3688 * To keep pine address builder happy, addresses should be separated
3689 * by ", ". Add this space if needed, otherwise...
3690 * (This is some ancient requirement that is no longer needed.)
3691 *
3692 * If this line is NOT a continuation of the previous line, add
3693 * white space for pine's address builder if its not already there...
3694 * (This is some ancient requirement that is no longer needed.)
3695 *
3696 * Also if it's not a continuation (i.e., there's already and addr on
3697 * the line), and there's another line below, treat the new line as
3698 * an implied comma.
3699 * (This should only be done for address-type lines, not for regular
3700 * text lines like subjects. Key off of the break_on_comma bit which
3701 * should only be set on those that won't mind a comma being added.)
3702 */
3714 }
3719 }
3720 }
3726 }
3727 }
3728 }
3735 }
3738 }
3741 /* check if any non-sticky affected entries */
3746 /* there is at least one non-sticky so make a list to pass */
3754 }
3760 }
3761 }
3767 }
3775 }
3776 }
3781 }
3782 }
3783 }
3784 }
3786 /*
3787 * Even if there are no affected entries, we still need the arg
3788 * to pass the "me" pointer.
3789 */
3795 }
3801 }
3802 }
3804 /*
3805 * The builder may make a new call back to pico() so we save and
3806 * restore the pico state.
3807 */
3813 }
3819 }
3825 }
3834 }
3837 e;
3843 /* make sure they see it if changed */
3852 }
3856 }
3857 }
3858 }
3864 /* Don't free xtra or me, they just point to headerentry data */
3870 }
3874 }
3877 void
3879 {
3887 /*
3888 * Since expander may make a call back to pico() we need to
3889 * save and restore pico state.
3890 */
3905 /*
3906 * Use tbuf to cat together multiple line entries before comparing.
3907 */
3914 e++;
3924 }
3925 }
3931 }
3940 }
3941 }
3949 /*
3950 * If any of the lines for this entry are current or
3951 * top, fix that.
3952 */
3959 }
3962 }
3963 }
3966 }
3975 }
3976 }
3979 }
3982 /*
3983 * strend - neglecting white space, returns TRUE if c is at the
3984 * end of the given line. otherwise FALSE.
3985 */
3986 int
3988 {
3997 }
4000 }
4003 /*
4004 * ucs4_strqchr - returns pointer to first non-quote-enclosed occurance of ch in
4005 * the given string. otherwise NULL.
4006 * s -- the string
4007 * ch -- the character we're looking for
4008 * q -- q tells us if we start out inside quotes on entry and is set
4009 * correctly on exit.
4010 * m -- max characters we'll check for ch (set to -1 for no max)
4011 */
4012 UCS *
4014 {
4022 }
4026 }
4029 }
4032 /*
4033 * KillHeaderLine() - kill a line in the header
4034 *
4035 * notes:
4036 * This is pretty simple. Just using the emacs kill buffer
4037 * and its accompanying functions to cut the text from lines.
4038 *
4039 * returns:
4040 * TRUE if hldelete worked
4041 * FALSE otherwise
4042 */
4043 int
4045 {
4057 /*put to be deleted part into kill buffer */
4063 }
4068 #ifdef _WINDOWS
4070 #endif
4084 }
4088 }
4099 }
4100 }
4104 /*
4105 * SaveHeaderLines() - insert the saved lines in the list before the
4106 * current line in the header
4107 *
4108 * notes:
4109 * Once again, just using emacs' kill buffer and its
4110 * functions.
4111 *
4112 * returns:
4113 * TRUE if something good happened
4114 * FALSE otherwise
4115 */
4116 int
4118 {
4131 }
4132 }
4133 else
4148 }
4149 }
4153 }
4154 }
4156 }
4158 /* insert new text at the dot position */
4166 }
4182 /* insert text in HLSZ character chunks */
4201 /*
4202 * This comes after the break above because it will
4203 * be accounted for in the while loop below.
4204 */
4208 else
4210 }
4213 }
4217 }
4218 }
4220 /* insert the remainder of text */
4237 else
4239 }
4246 }
4255 }
4256 }
4257 }
4261 }
4265 /*
4266 * break_point - Break the given line at the most reasonable character breakch
4267 * within maxwid max characters.
4268 *
4269 * returns:
4270 * Pointer to the best break point in s, or
4271 * Pointer to the beginning of s if no break point found
4272 */
4273 UCS *
4275 {
4279 /*
4280 * Start at maxwid and work back until first opportunity to break.
4281 */
4284 /*
4285 * Quoted should be set up for the start of line. Since we want
4286 * to move to bp and work our way back we need to scan through the
4287 * line up to bp setting quoted appropriately.
4288 */
4303 }
4304 }
4306 /*
4307 * if break char isn't a space, leave a space after
4308 * the break char.
4309 */
4314 }
4315 }
4316 }
4318 bp--;
4319 }
4325 }
4330 /*
4331 * hldelete() - remove the header line pointed to by l from the linked list
4332 * of lines.
4333 *
4334 * notes:
4335 * the case of first line in field is kind of bogus. since
4336 * the array of headers has a pointer to the first line, and
4337 * i don't want to worry about this too much, i just copied
4338 * the line below and removed it rather than the first one
4339 * from the list.
4340 *
4341 * returns:
4342 * TRUE if it worked
4343 * FALSE otherwise
4344 */
4345 int
4347 {
4356 }
4359 }
4367 }
4371 }
4377 }
4381 /*
4382 * is_blank - returns true if the next n chars from coordinates row, col
4383 * on display are spaces
4384 */
4385 int
4387 {
4392 }
4394 }
4397 /*
4398 * ShowPrompt - display key help corresponding to the current header entry
4399 */
4400 void
4402 {
4407 }
4408 else
4415 else
4422 }
4427 }
4432 }
4435 }
4439 }
4445 }
4446 else
4450 }
4456 }
4459 }
4462 /*
4463 * packheader - packup all of the header fields for return to caller.
4464 * NOTE: all of the header info passed in, including address
4465 * of the pointer to each string is contained in the
4466 * header entry array "headents".
4467 */
4468 int
4470 {
4482 #ifdef ATTACHMENTS
4483 /*
4484 * attachments are special case, already in struct we pass back
4485 */
4487 i++;
4489 }
4490 #endif
4493 i++;
4495 }
4497 /*
4498 * count chars to see if we need a new malloc'd space for our
4499 * array.
4500 */
4504 /*
4505 * add one for possible concatenation of a ' ' character ...
4506 */
4511 count++;
4514 }
4517 }
4522 }
4524 /*
4525 * don't forget to include space for the null terminator!!!!
4526 */
4533 }
4537 }
4538 }
4545 /* pass the cursor offset back in Pmaster struct */
4548 saw_current_line++;
4549 else
4551 }
4561 }
4564 }
4567 }
4568 }
4570 i++;
4571 }
4574 }
4578 /*
4579 * zotheader - free all malloc'd lines associated with the header structs
4580 */
4581 void
4583 {
4588 }
4591 /*
4592 * zotentry - free malloc'd space associated with the given linked list
4593 */
4594 void
4596 {
4603 }
4604 }
4608 /*
4609 * zotcomma - blast any trailing commas and white space from the end
4610 * of the given line
4611 */
4612 int
4614 {
4624 }
4627 }
4628 }
4631 }
4634 /*
4635 * Save the current state of global variables so that we can restore
4636 * them later. This is so we can call pico again.
4637 * Also have to initialize some variables that normally would be set to
4638 * zero on startup.
4639 */
4640 VARS_TO_SAVE *
4642 {
4694 /* Initialize for next pico call */
4701 }
4704 void
4706 {
4750 }
4758 }
4761 void
4763 {
4771 }
4774 /*
4775 * Ok to call this twice in a row because it won't do anything the second
4776 * time.
4777 */
4778 void
4780 {
4786 }
4795 }
4796 else
4801 }
4802 }
4805 /*
4806 * What is this for?
4807 * This is so that the To line will be appended to by an Lcc
4808 * entry unless the user types in the To line after the Lcc
4809 * has already been set.
4810 */
4811 void
4813 {
4816 }
4819 #ifdef MOUSE
4820 #undef HeaderEditor
4822 /*
4823 * Wrapper function for the real header editor.
4824 * Does the important tasks of:
4825 * 1) verifying that we _can_ edit the headers.
4826 * 2) acting on the result code from the header editor.
4827 */
4828 int
4830 {
4834 #ifdef _WINDOWS
4835 /* Sometimes we get here from a scroll callback, which
4836 * is no good at all because mswin is not ready to process input and
4837 * this _headeredit() will never do anything.
4838 * Putting this test here was the most general solution I could think
4839 * of. */
4842 #endif
4847 }
4849 }
4850 #endif