| blob | a20314b5096973fef6b847f6be44ff8494841b36 |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2006-2009 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: 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 }
3421 }
3422 }
3426 /*
3427 * InvertPrompt() - invert the prompt associated with header entry to state
3428 * state (true if invert, false otherwise).
3429 * returns:
3430 * non-zero if nothing done
3431 * 0 if prompt inverted successfully
3432 *
3433 * notes:
3434 * come to think of it, this func and the one above could
3435 * easily be combined
3436 */
3437 int
3439 {
3452 }
3456 /*
3457 * Makes sure that the prompt doesn't take up more than prwid of screen space.
3458 * The caller should do that, too, in order to make it look right so
3459 * this should most likely be a no-op
3460 */
3464 }
3471 ;
3476 else
3481 }
3482 }
3487 else
3489 }
3506 }
3510 /*
3511 * partial_entries() - toggle display of the bcc and fcc fields.
3512 *
3513 * returns:
3514 * TRUE if there are partial entries on the display
3515 * FALSE otherwise.
3516 */
3517 int
3519 {
3523 /*---- find out status of first rich header ---*/
3525 ;
3533 }
3537 /*
3538 * entry_line() - return the physical line on the screen associated
3539 * with the given header entry field. Note: the field
3540 * may span lines, so if the last char is set, return
3541 * the appropriate value.
3542 *
3543 * returns:
3544 * 1) physical line number of entry
3545 * 2) -1 if entry currently not on display
3546 */
3547 int
3549 {
3556 p_line++){
3563 }
3566 else
3568 }
3570 }
3572 }
3576 /*
3577 * physical_line() - return the physical line on the screen associated
3578 * with the given header line pointer.
3579 *
3580 * returns:
3581 * 1) physical line number of entry
3582 * 2) -1 if entry currently not on display
3583 */
3584 int
3586 {
3599 }
3601 }
3605 /*
3606 * call_builder() - resolve any nicknames in the address book associated
3607 * with the given entry...
3608 *
3609 * NOTES:
3610 *
3611 * BEWARE: this function can cause cur_l and top_l to get lost so BE
3612 * CAREFUL before and after you call this function!!!
3613 *
3614 * There could to be something here to resolve cur_l and top_l
3615 * reasonably into the new linked list for this entry.
3616 *
3617 * The reason this would mostly work without it is resolve_niks gets
3618 * called for the most part in between fields. Since we're moving
3619 * to the beginning or end (i.e. the next/prev pointer in the old
3620 * freed cur_l is NULL) of the next entry, we get a new cur_l
3621 * pointing at a good line. Then since top_l is based on cur_l in
3622 * NewTop() we have pretty much lucked out.
3623 *
3624 * Where we could get burned is in a canceled exit (ctrl|x). Here
3625 * nicknames get resolved into addresses, which invalidates cur_l
3626 * and top_l. Since we don't actually leave, we could begin editing
3627 * again with bad pointers. This would usually results in a nice
3628 * core dump.
3629 *
3630 * NOTE: The mangled argument is a little strange. It's used on both
3631 * input and output. On input, if it is not set, then that tells the
3632 * builder not to do anything that might take a long time, like a
3633 * white pages lookup. On return, it tells the caller that the screen
3634 * and signals may have been mangled so signals should be reset, window
3635 * resized, and screen redrawn.
3636 *
3637 * RETURNS:
3638 * > 0 if any names where resolved, otherwise
3639 * 0 if not, or
3640 * < 0 on error
3641 * -1: move to next line
3642 * -2: don't move off this line
3643 */
3644 int
3646 {
3667 }
3672 }
3676 /*
3677 * cat the whole entry into one string...
3678 */
3683 /*
3684 * To keep pine address builder happy, addresses should be separated
3685 * by ", ". Add this space if needed, otherwise...
3686 * (This is some ancient requirement that is no longer needed.)
3687 *
3688 * If this line is NOT a continuation of the previous line, add
3689 * white space for pine's address builder if its not already there...
3690 * (This is some ancient requirement that is no longer needed.)
3691 *
3692 * Also if it's not a continuation (i.e., there's already and addr on
3693 * the line), and there's another line below, treat the new line as
3694 * an implied comma.
3695 * (This should only be done for address-type lines, not for regular
3696 * text lines like subjects. Key off of the break_on_comma bit which
3697 * should only be set on those that won't mind a comma being added.)
3698 */
3710 }
3715 }
3716 }
3722 }
3723 }
3724 }
3731 }
3734 }
3737 /* check if any non-sticky affected entries */
3742 /* there is at least one non-sticky so make a list to pass */
3750 }
3756 }
3757 }
3763 }
3771 }
3772 }
3777 }
3778 }
3779 }
3780 }
3782 /*
3783 * Even if there are no affected entries, we still need the arg
3784 * to pass the "me" pointer.
3785 */
3791 }
3797 }
3798 }
3800 /*
3801 * The builder may make a new call back to pico() so we save and
3802 * restore the pico state.
3803 */
3809 }
3815 }
3821 }
3830 }
3833 e;
3839 /* make sure they see it if changed */
3848 }
3852 }
3853 }
3854 }
3860 /* Don't free xtra or me, they just point to headerentry data */
3866 }
3870 }
3873 void
3875 {
3883 /*
3884 * Since expander may make a call back to pico() we need to
3885 * save and restore pico state.
3886 */
3901 /*
3902 * Use tbuf to cat together multiple line entries before comparing.
3903 */
3910 e++;
3920 }
3921 }
3927 }
3936 }
3937 }
3945 /*
3946 * If any of the lines for this entry are current or
3947 * top, fix that.
3948 */
3955 }
3958 }
3959 }
3962 }
3971 }
3972 }
3975 }
3978 /*
3979 * strend - neglecting white space, returns TRUE if c is at the
3980 * end of the given line. otherwise FALSE.
3981 */
3982 int
3984 {
3993 }
3996 }
3999 /*
4000 * ucs4_strqchr - returns pointer to first non-quote-enclosed occurance of ch in
4001 * the given string. otherwise NULL.
4002 * s -- the string
4003 * ch -- the character we're looking for
4004 * q -- q tells us if we start out inside quotes on entry and is set
4005 * correctly on exit.
4006 * m -- max characters we'll check for ch (set to -1 for no max)
4007 */
4008 UCS *
4010 {
4018 }
4022 }
4025 }
4028 /*
4029 * KillHeaderLine() - kill a line in the header
4030 *
4031 * notes:
4032 * This is pretty simple. Just using the emacs kill buffer
4033 * and its accompanying functions to cut the text from lines.
4034 *
4035 * returns:
4036 * TRUE if hldelete worked
4037 * FALSE otherwise
4038 */
4039 int
4041 {
4053 /*put to be deleted part into kill buffer */
4059 }
4064 #ifdef _WINDOWS
4066 #endif
4080 }
4084 }
4095 }
4096 }
4100 /*
4101 * SaveHeaderLines() - insert the saved lines in the list before the
4102 * current line in the header
4103 *
4104 * notes:
4105 * Once again, just using emacs' kill buffer and its
4106 * functions.
4107 *
4108 * returns:
4109 * TRUE if something good happened
4110 * FALSE otherwise
4111 */
4112 int
4114 {
4127 }
4128 }
4129 else
4144 }
4145 }
4149 }
4150 }
4152 }
4154 /* insert new text at the dot position */
4162 }
4178 /* insert text in HLSZ character chunks */
4197 /*
4198 * This comes after the break above because it will
4199 * be accounted for in the while loop below.
4200 */
4204 else
4206 }
4209 }
4213 }
4214 }
4216 /* insert the remainder of text */
4233 else
4235 }
4242 }
4251 }
4252 }
4253 }
4257 }
4261 /*
4262 * break_point - Break the given line at the most reasonable character breakch
4263 * within maxwid max characters.
4264 *
4265 * returns:
4266 * Pointer to the best break point in s, or
4267 * Pointer to the beginning of s if no break point found
4268 */
4269 UCS *
4271 {
4275 /*
4276 * Start at maxwid and work back until first opportunity to break.
4277 */
4280 /*
4281 * Quoted should be set up for the start of line. Since we want
4282 * to move to bp and work our way back we need to scan through the
4283 * line up to bp setting quoted appropriately.
4284 */
4299 }
4300 }
4302 /*
4303 * if break char isn't a space, leave a space after
4304 * the break char.
4305 */
4310 }
4311 }
4312 }
4314 bp--;
4315 }
4321 }
4326 /*
4327 * hldelete() - remove the header line pointed to by l from the linked list
4328 * of lines.
4329 *
4330 * notes:
4331 * the case of first line in field is kind of bogus. since
4332 * the array of headers has a pointer to the first line, and
4333 * i don't want to worry about this too much, i just copied
4334 * the line below and removed it rather than the first one
4335 * from the list.
4336 *
4337 * returns:
4338 * TRUE if it worked
4339 * FALSE otherwise
4340 */
4341 int
4343 {
4352 }
4355 }
4363 }
4367 }
4373 }
4377 /*
4378 * is_blank - returns true if the next n chars from coordinates row, col
4379 * on display are spaces
4380 */
4381 int
4383 {
4388 }
4390 }
4393 /*
4394 * ShowPrompt - display key help corresponding to the current header entry
4395 */
4396 void
4398 {
4403 }
4404 else
4411 else
4418 }
4423 }
4428 }
4431 }
4435 }
4441 }
4442 else
4446 }
4452 }
4455 }
4458 /*
4459 * packheader - packup all of the header fields for return to caller.
4460 * NOTE: all of the header info passed in, including address
4461 * of the pointer to each string is contained in the
4462 * header entry array "headents".
4463 */
4464 int
4466 {
4478 #ifdef ATTACHMENTS
4479 /*
4480 * attachments are special case, already in struct we pass back
4481 */
4483 i++;
4485 }
4486 #endif
4489 i++;
4491 }
4493 /*
4494 * count chars to see if we need a new malloc'd space for our
4495 * array.
4496 */
4500 /*
4501 * add one for possible concatenation of a ' ' character ...
4502 */
4507 count++;
4510 }
4513 }
4518 }
4520 /*
4521 * don't forget to include space for the null terminator!!!!
4522 */
4529 }
4533 }
4534 }
4541 /* pass the cursor offset back in Pmaster struct */
4544 saw_current_line++;
4545 else
4547 }
4557 }
4560 }
4563 }
4564 }
4566 i++;
4567 }
4570 }
4574 /*
4575 * zotheader - free all malloc'd lines associated with the header structs
4576 */
4577 void
4579 {
4584 }
4587 /*
4588 * zotentry - free malloc'd space associated with the given linked list
4589 */
4590 void
4592 {
4599 }
4600 }
4604 /*
4605 * zotcomma - blast any trailing commas and white space from the end
4606 * of the given line
4607 */
4608 int
4610 {
4620 }
4623 }
4624 }
4627 }
4630 /*
4631 * Save the current state of global variables so that we can restore
4632 * them later. This is so we can call pico again.
4633 * Also have to initialize some variables that normally would be set to
4634 * zero on startup.
4635 */
4636 VARS_TO_SAVE *
4638 {
4690 /* Initialize for next pico call */
4697 }
4700 void
4702 {
4746 }
4754 }
4757 void
4759 {
4767 }
4770 /*
4771 * Ok to call this twice in a row because it won't do anything the second
4772 * time.
4773 */
4774 void
4776 {
4782 }
4791 }
4792 else
4797 }
4798 }
4801 /*
4802 * What is this for?
4803 * This is so that the To line will be appended to by an Lcc
4804 * entry unless the user types in the To line after the Lcc
4805 * has already been set.
4806 */
4807 void
4809 {
4812 }
4815 #ifdef MOUSE
4816 #undef HeaderEditor
4818 /*
4819 * Wrapper function for the real header editor.
4820 * Does the important tasks of:
4821 * 1) verifying that we _can_ edit the headers.
4822 * 2) acting on the result code from the header editor.
4823 */
4824 int
4826 {
4830 #ifdef _WINDOWS
4831 /* Sometimes we get here from a scroll callback, which
4832 * is no good at all because mswin is not ready to process input and
4833 * this _headeredit() will never do anything.
4834 * Putting this test here was the most general solution I could think
4835 * of. */
4838 #endif
4843 }
4845 }
4846 #endif