| blob | 65408aa06b12c47e0bc3e3c90a23dc871716612f |
1 /*
2 * ========================================================================
3 * Copyright 2006-2009 University of Washington
4 * Copyright 2013-2022 Eduardo Chappa
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * ========================================================================
13 *
14 * Program: Pine composer routines
15 *
16 * NOTES:
17 *
18 * - composer.c is the composer for the PINE mail system
19 *
20 * - tabled 01/19/90
21 *
22 * Notes: These routines aren't incorporated yet, because the composer as
23 * a whole still needs development. These are ideas that should
24 * be implemented in later releases of PINE. See the notes in
25 * pico.c concerning what needs to be done ....
26 *
27 * - untabled 01/30/90
28 *
29 * Notes: Installed header line editing, with wrapping and unwrapping,
30 * context sensitive help, and other mail header editing features.
31 *
32 * - finalish code cleanup 07/15/91
33 *
34 * Notes: Killed/yanked header lines use emacs kill buffer.
35 * Arbitrarily large headers are handled gracefully.
36 * All formatting handled by FormatLines.
37 *
38 * - Work done to optimize display painting 06/26/92
39 * Not as clean as it should be, needs more thought
40 *
41 */
81 /*
82 * definition header field array, structures defined in pico.h
83 */
87 /*
88 * structure that keeps track of the range of header lines that are
89 * to be displayed and other fun stuff about the header
90 */
93 /* a pointer to the subject line. This is so that we do not have to compute
94 * the header line in every call. It saves a few CPU cycles
95 */
99 /*
100 * useful macros
101 */
102 #define HALLOC() (struct hdr_line *)malloc(sizeof(struct hdr_line))
103 #define LINEWID() (((term.t_ncol - headents[ods.cur_e].prwid) > 0) ? ((unsigned) (term.t_ncol - headents[ods.cur_e].prwid)) : 0)
104 #define BOTTOM() (term.t_nrow - term.t_mrow)
105 #define FULL_SCR() (BOTTOM() - 3)
106 #define HALF_SCR() (FULL_SCR()/2)
108 #ifdef MOUSE
109 /*
110 * Redefine HeaderEditor to install wrapper required for mouse event
111 * handling...
112 */
113 #define HeaderEditor HeaderEditorWork
118 /*
119 * useful declarations
120 */
126 /* TRANSLATORS: command key labels, Send means send the message
127 we are currently working on. */
129 /* TRANSLATORS: Rich Headers is a command to display more headers. It
130 is triggered with the ^R key. PrvPg stands for Previous Page. */
132 /* TRANSLATORS: Cut Line means remove a line. Postpone means to save
133 a message being composed so that it can be worked on later. */
135 /* TRANSLATORS: Del Char is Delete Character */
137 /* TRANSLATORS: Next Page */
139 /* TRANSLATORS: Undelete a line that was just deleted */
141 };
142 #define SEND_KEY 1
143 #define RICH_KEY 2
144 #define CUT_KEY 4
145 #define PONE_KEY 5
146 #define DEL_KEY 7
147 #define ATT_KEY 8
148 #define UDEL_KEY 10
149 #define TO_KEY 11
152 /*
153 * function key mappings for header editor
154 */
168 };
171 /*
172 * InitMailHeader - initialize header array, and set beginning editor row
173 * range. The header entry structure should look just like
174 * what is written on the screen, the vector
175 * (entry, line, offset) will describe the current cursor
176 * position in the header.
177 *
178 * Returns: TRUE if special header handling was requested,
179 * FALSE under standard default behavior.
180 */
181 int
183 {
191 }
193 /*
194 * initialize some of on_display structure, others below...
195 */
201 /*--- initialize the fields in the headerent structure ----*/
206 /*--- A lot of work to do since attachments are special ---*/
224 }
228 }
233 ofp1,
240 /* append description, escaping quotes */
245 do
248 ofp2--;
249 }
253 }
257 }
267 }
268 }
272 }
274 }
279 }
284 else
288 }
289 }
291 /*
292 * finish initialization and then figure out display layout.
293 * first, look for any field the caller requested we start in,
294 * and set the offset into that field.
295 */
303 }
309 }
313 }
317 /*
318 * InitEntryText - Add the given header text into the header entry
319 * line structure.
320 */
321 int
323 {
327 /*
328 * get first chunk of memory, and tie it to structure...
329 */
333 }
343 else
345 }
349 /*
350 * ResizeHeader - Handle resizing display when SIGWINCH received.
351 *
352 * notes:
353 * works OK, but needs thorough testing
354 *
355 */
356 int
358 {
371 }
372 }
381 i--;
390 }
393 }
405 }
409 /*
410 * HeaderOffset - return the character offset into the given header
411 */
412 int
414 {
423 }
425 }
429 /*
430 * HeaderFocus - put the dot at the given offset into the given header
431 */
432 int
434 {
446 }
450 else
452 }
455 }
462 }
466 /*
467 * HeaderEditor() - edit the mail header field by field, trapping
468 * important key sequences, hand the hard work off
469 * to LineEdit().
470 * returns:
471 * -3 if we drop out bottom *and* want to process mouse event
472 * -1 if we drop out the bottom
473 * FALSE if editing is cancelled
474 * TRUE if editing is finished
475 */
476 int
478 {
486 #ifdef MOUSE
487 MOUSEPRESS mp;
488 #endif
496 #ifdef _WINDOWS
505 /*
506 * Decide where to begin editing. if f == TRUE begin editing
507 * at the bottom. this case results from the cursor backing
508 * into the editor from the bottom. otherwise, the user explicitly
509 * requested editing the header, and we begin at the top.
510 *
511 * further, if f == 1, we moved into the header by hitting the up arrow
512 * in the message text, else if f == 2, we moved into the header by
513 * moving past the left edge of the top line in the message. so, make
514 * the end of the last line of the last entry the current cursor position
515 * lastly, if f == 3, we moved into the header by hitting backpage() on
516 * the top line of the message, so scroll a page back.
517 */
523 /*--- make sure on last field ---*/
528 }
531 }
533 /*
534 * note: assumes that ods.cur_e and ods.cur_l haven't changed
535 * since we left...
536 */
538 /* fix position */
543 else
546 /* and scroll back if needed */
549 ;
550 }
553 }
554 /* else just trust what ods contains */
562 km_popped--;
565 }
573 }
582 }
583 }
591 km_popped++;
602 }
612 }
613 else
615 }
617 /*---- Are there any headers to expand above us? ---*/
627 /*--- Just turned off all rich headers --*/
629 /*-- current header got turned off too --*/
630 #ifdef ATTACHMENTS
632 /* verify the attachments */
637 }
638 }
639 #endif
642 /* Check below */
647 /* didn't find one, check above */
649 cur_e--)
653 }
657 }
658 }
675 #ifdef ATTACHMENTS
677 /* verify the attachments, and pretty things up in case
678 * we come back to the composer due to error...
679 */
685 }
686 }
687 else
688 #endif
697 }
704 }
712 /*
713 * need to be careful here because pointers might be messed up.
714 * also, could do a better job of finding the right place to
715 * put the dot back (i.e., the addr/list that was expanded).
716 */
720 }
727 }
728 else
734 #if defined MOUSE && !defined(_WINDOWS)
736 #else
738 #endif
760 }
761 }
762 }
774 #ifdef ATTACHMENTS
785 /*
786 * Attachment questions mess with km_popped and assume
787 * it is zero to start with. If we don't set it to zero
788 * on entry, the message about mime type will be erased
789 * by PaintBody. If we don't reset it when we come back,
790 * the bottom three lines may be messed up.
791 */
808 NULL);
810 }
811 }
815 }
820 else
829 }
832 }
836 }
838 #endif
860 && (*start
869 start--;
872 start++;
875 add_a_comma++;
877 /*
878 * Nickname prefix begins with start and ends
879 * with end-1. Replace those characters with
880 * completed nickname.
881 */
889 /*
890 * Ambiguity == 0 means no matches exist.
891 * 1 means it is ambiguous and the longest
892 * unambiguous prefix beginning with prefix
893 * is in new_nickname.
894 * 2 means it is unambiguous and the answer
895 * is in new_nickname
896 *
897 * The expansion from == 2 doesn't have to have prefix
898 * as a prefix. For example, if the prefix is a prefix
899 * of the full name or a prefix of a nickname the answer
900 * might be the full address instead of the expanded
901 * prefix. In fact, that's probably the expected thing.
902 *
903 * Due to the way the build_abook_tries sets up the tries
904 * it is unfortunately the case that the expanded address
905 * is not entered in any trie, so after you get an
906 * unambiguous expansion if you try TAB again at that
907 * point you'll probably get a no match returned instead
908 * of an unambiguous. So be aware of that and handle
909 * that case ok by falling through to header_downline.
910 */
914 /*
915 * Don't fall through on no-match TAB unless
916 * it is the second TAB.
917 */
921 }
931 /*
932 * We're trying to work with the way
933 * FormatLines works. It inserts text at the
934 * beginning of the line we pass in.
935 * So, remove the beginning of the line and
936 * have FormatLines put it back.
937 */
939 /* save part before start */
947 /* figure out new cursor offset */
952 }
956 /*
957 * Delete everything up to end by
958 * copying characters to start of buffer.
959 */
972 /* add a comma? */
974 l++;
975 offset++;
976 }
977 else
982 /*
983 * Insert is the before start stuff plus the
984 * new nickname, and we're going to let
985 * FormatLines put it together for us.
986 */
994 }
997 }
1004 }
1010 }
1013 }
1017 }
1022 }
1038 }
1051 }
1054 }
1057 }
1059 nomore_to_complete:
1061 }
1080 }
1089 /*
1090 * Count down move_down lines to find the pointer to the line
1091 * that we want to become the current line.
1092 */
1101 }
1109 }
1111 /*
1112 * Now call header_downline until we get down to the
1113 * new current line, so that the builders all get called.
1114 * New_cur_l will remain valid since we won't be calling
1115 * a builder for it during this loop.
1116 */
1118 ;
1120 /*
1121 * Count back up, if we're at the bottom, to find the new
1122 * top line.
1123 */
1126 /*
1127 * Cursor stops at bottom of headers, which is where
1128 * we are right now. Put as much of headers on
1129 * screen as will fit. Count up to figure
1130 * out which line is top_l and which p_line cursor is on.
1131 */
1134 /* leave delimiter on screen, too */
1142 }
1148 }
1152 /*
1153 * We don't want to scroll down further than the
1154 * delimiter, so check to see if that is the case.
1155 * If it is, we move the p_line down the screen
1156 * until the bottom line is where we want it.
1157 */
1167 }
1169 /*
1170 * i is the desired value of p_line.
1171 * If it is greater than COMPOSER_TOP_LINE, then
1172 * we need to adjust top_l.
1173 */
1183 }
1188 /*
1189 * Special case. If p_line is within one of the bottom,
1190 * move it to the bottom.
1191 */
1194 /* but put these back where we want them */
1198 }
1199 }
1204 }
1216 #ifdef MOUSE
1226 ;
1227 }
1232 ;
1233 }
1238 /* -3 is returned if we drop out bottom
1239 * *and* want to process a mousepress. The Headereditor
1240 * wrapper should make sense of this return code.
1241 */
1244 }
1249 #ifdef _WINDOWS
1251 #endif
1255 }
1263 /*--- selector for attachments ----*/
1270 ? opertree
1293 NULL);
1295 }
1296 }
1300 }
1305 else
1317 }
1323 }
1330 /*---- General selector for non-attachments -----*/
1332 /*
1333 * Since the selector may make a new call back to pico()
1334 * we need to save and restore the pico state here.
1335 */
1342 }
1352 }
1358 /*--- Must be an address ---*/
1360 /*
1361 * If current line is empty and there are more
1362 * lines that follow, delete the empty lines
1363 * before adding the new address.
1364 */
1370 }
1378 /* cur is not first line */
1380 /*
1381 * Protect against adding a new entry into
1382 * the middle of a long, continued entry.
1383 */
1390 }
1396 }
1401 }
1402 }
1408 }
1414 NULL);
1417 }
1419 /*
1420 * If the "selector" has a "builder" as well, pass
1421 * what was just selected thru the builder...
1422 */
1430 ;
1438 }
1443 ;
1447 }
1458 }
1459 }
1462 /* mark this entry dirty */
1466 }
1468 /*----- No selector -----*/
1471 }
1479 }
1488 }
1489 }
1506 /*
1507 * Since the fileedit will make a new call back to pico()
1508 * we need to save and restore the pico state here.
1509 */
1526 }
1537 }
1546 }
1555 }
1558 }
1559 else
1565 bleep:
1570 }
1571 }
1582 }
1585 }
1588 /*
1589 *
1590 */
1591 int
1593 {
1597 /* calculate the next line: physical *and* logical */
1618 }
1621 }
1623 /*
1624 * Because of blank header lines the cursor may need to move down
1625 * more than one line. Figure out how far.
1626 */
1631 incr++;
1632 else
1634 }
1639 /* expand what needs expanding */
1651 }
1666 }
1672 }
1675 }
1680 }
1681 }
1688 }
1698 }
1699 }
1702 }
1705 /*
1706 *
1707 */
1708 int
1710 {
1713 EML eml;
1715 /* calculate the next line: physical *and* logical */
1723 }
1726 }
1728 /*
1729 * Because of blank header lines the cursor may need to move up
1730 * more than one line. Figure out how far.
1731 */
1736 incr++;
1737 else
1739 }
1753 }
1754 }
1761 /* repair new_l */
1765 ;
1767 /* and cur_l (required in fix_and... */
1769 }
1775 }
1778 }
1782 }
1793 }
1796 }
1799 /*
1800 *
1801 */
1802 int
1804 {
1810 /*--- Find headerentry that is attachments (only first) --*/
1813 /* make sure field stays displayed */
1817 }
1819 /* append new attachment line */
1821 ;
1823 /* build new attachment line */
1834 }
1838 }
1839 }
1851 }
1853 /* validate the new attachment, and reformat if needed */
1855 EML eml;
1860 }
1867 }
1868 }
1874 }
1877 /*
1878 * LineEdit - Always use insert mode and handle line wrapping
1879 *
1880 * returns:
1881 * Any characters typed in that aren't printable
1882 * (i.e. commands)
1883 *
1884 * notes:
1885 * Assume we are guaranteed that there is sufficiently
1886 * more buffer space in a line than screen width (just one
1887 * less thing to worry about). If you want to change this,
1888 * then pputc will have to be taught to check the line buffer
1889 * length, and HALLOC() will probably have to become a func.
1890 */
1891 UCS
1893 {
1914 }
1925 else
1934 #ifdef MOUSE
1938 #endif
1939 #ifdef _WINDOWS
1942 #endif
1950 }
1952 #ifdef MOUSE
1954 #endif
1955 #ifdef _WINDOWS
1958 #endif
1977 }
1991 }
1992 }
2001 }
2008 }
2009 }
2014 /*
2015 * if we are allowing editing, insert the new char
2016 * end up leaving tbufp pointing to newly
2017 * inserted character in string, and offset to the
2018 * index of the character after the inserted ch ...
2019 */
2024 }
2030 }
2032 /*
2033 * go ahead and add the character...
2034 */
2041 }
2043 /* mark this entry dirty */
2047 /*
2048 * then find out where things fit...
2049 */
2051 CELL c;
2058 }
2059 }
2065 }
2067 /*
2068 * during the format, the dot may have moved
2069 * down to the next line...
2070 */
2076 }
2079 }
2085 }
2086 }
2090 }
2091 }
2099 {
2103 }
2109 /* Bail if the character right before this one is whitespace */
2113 }
2127 }
2135 }
2150 }
2157 km_popped--;
2160 }
2164 }
2175 }
2181 km_popped--;
2184 }
2191 }
2192 else
2193 /* TRANSLATORS: Killing text is deleting it and
2194 Unkilling text is undeleting killed text. */
2203 }
2215 }
2239 }
2246 }
2255 }
2260 }
2267 else
2276 }
2281 }
2289 }
2293 }
2296 }
2302 }
2304 /*
2305 * beware, the dot may have moved...
2306 */
2315 }
2323 }
2335 }
2336 }
2343 }
2344 }
2347 void
2349 {
2350 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);
2351 }
2355 /*
2356 * FormatLines - Place the given text at the front of the given line->text
2357 * making sure to properly format the line, then check
2358 * all lines below for proper format.
2359 *
2360 * notes:
2361 * Not much optimization at all. Right now, it recursively
2362 * fixes all remaining lines in the entry. Some speed might
2363 * gained if this was built to iteratively scan the lines.
2364 *
2365 * returns:
2366 * -1 on error
2367 * FALSE if only this line is changed
2368 * TRUE if text below the first line is changed
2369 */
2370 int
2376 {
2399 }
2408 ;
2420 }
2430 }
2436 }
2438 /*
2439 * Break at maxwid - width of istr
2440 */
2443 }
2444 }
2445 else
2454 }
2458 /*
2459 * shift ostr i chars
2460 */
2465 }
2466 }
2467 }
2468 }
2469 /*
2470 * Short-circuit the recursion in this case.
2471 * No time right now to figure out how to do it better.
2472 */
2487 }
2493 }
2509 }
2520 }
2522 /*
2523 * Now l is still > maxwid. Do it the recursive way,
2524 * like the else clause below. Surely we could fix up the
2525 * flow control some here, but this works for now.
2526 */
2534 }
2541 }
2547 }
2558 }
2565 }
2571 }
2582 }
2592 }
2603 }
2604 }
2616 }
2635 }
2646 }
2647 }
2658 ;
2663 }
2664 else
2666 }
2667 else
2678 }
2679 }
2695 }
2696 else
2698 }
2699 }
2700 }
2707 }
2709 }
2729 }
2732 }
2735 }
2736 else
2738 }
2740 /*
2741 * Format the lines before parsing attachments so we
2742 * don't expand a bunch of attachments that we don't
2743 * have the buffer space for.
2744 */
2745 int
2747 {
2752 }
2755 /*
2756 * PaintHeader - do the work of displaying the header from the given
2757 * physical screen line the end of the header.
2758 *
2759 * 17 July 91 - fixed reshow to deal with arbitrarily large headers.
2760 */
2761 void
2764 {
2777 }
2788 }
2800 }
2801 }
2807 }
2813 }
2826 }
2836 }
2837 }
2842 }
2843 curline++;
2849 }
2858 }
2859 }
2866 }
2867 }
2871 /*
2872 * PaintBody() - generic call to handle repainting everything BUT the
2873 * header
2874 *
2875 * notes:
2876 * The header redrawing in a level 0 body paint gets done
2877 * in update()
2878 */
2879 void
2881 {
2891 }
2892 }
2895 /*
2896 * display_for_send - paint the composer from the top line and return.
2897 */
2898 void
2900 {
2904 /* if first header line isn't displayed, there's work to do */
2912 /*
2913 * fake that the cursor's in the first header line
2914 * and force repaint...
2915 */
2935 /* in case we don't exit, set up restoring the screen */
2937 }
2938 }
2941 /*
2942 * ArrangeHeader - set up display parm such that header is reasonably
2943 * displayed
2944 */
2945 void
2947 {
2958 }
2961 }
2964 /*
2965 * ComposerHelp() - display mail help in a context sensitive way
2966 * based on the level passed ...
2967 */
2968 int
2970 {
2982 }
2993 }
2998 }
3002 /*
3003 * ToggleHeader() - set or unset pico values to the full screen size
3004 * painting header if need be.
3005 */
3006 int
3008 {
3009 /*
3010 * check to see if we need to display the header...
3011 */
3015 }
3017 /*
3018 * set bounds for no header display
3019 */
3022 }
3024 }
3028 /*
3029 * HeaderLen() - return the length in lines of the exposed portion of the
3030 * header
3031 */
3032 int
3034 {
3044 i++;
3045 }
3047 }
3051 /*
3052 * first_hline() - return a pointer to the first displayable header line
3053 *
3054 * returns:
3055 * 1) pointer to first displayable line in header and header
3056 * entry, via side effect, that the first line is a part of
3057 * 2) NULL if no next line, leaving entry at LASTHDR
3058 */
3061 {
3062 /* init *entry so we're sure to start from the top */
3069 }
3072 /*
3073 * first_sel_hline() - return a pointer to the first selectable header line
3074 *
3075 * returns:
3076 * 1) pointer to first selectable line in header and header
3077 * entry, via side effect, that the first line is a part of
3078 * 2) NULL if no next line, leaving entry at LASTHDR
3079 */
3082 {
3083 /* init *entry so we're sure to start from the top */
3090 }
3094 /*
3095 * next_hline() - return a pointer to the next line structure
3096 *
3097 * returns:
3098 * 1) pointer to next displayable line in header and header
3099 * entry, via side effect, that the next line is a part of
3100 * 2) NULL if no next line, leaving entry at LASTHDR
3101 */
3104 {
3112 }
3115 }
3116 else
3118 }
3121 /*
3122 * next_sel_hline() - return a pointer to the next selectable line structure
3123 *
3124 * returns:
3125 * 1) pointer to next selectable line in header and header
3126 * entry, via side effect, that the next line is a part of
3127 * 2) NULL if no next line, leaving entry at LASTHDR
3128 */
3131 {
3139 }
3142 }
3143 else
3145 }
3149 /*
3150 * prev_hline() - return a pointer to the next line structure back
3151 *
3152 * returns:
3153 * 1) pointer to previous displayable line in header and
3154 * the header entry that the next line is a part of
3155 * via side effect
3156 * 2) NULL if no next line, leaving entry unchanged from
3157 * the value it had on entry.
3158 */
3161 {
3175 }
3176 }
3180 }
3181 else
3183 }
3186 /*
3187 * prev_sel_hline() - return a pointer to the previous selectable line
3188 *
3189 * returns:
3190 * 1) pointer to previous selectable line in header and
3191 * the header entry that the next line is a part of
3192 * via side effect
3193 * 2) NULL if no next line, leaving entry unchanged from
3194 * the value it had on entry.
3195 */
3198 {
3212 }
3213 }
3217 }
3218 else
3220 }
3224 /*
3225 * first_requested_hline() - return pointer to first line that pico's caller
3226 * asked that we start on.
3227 */
3230 {
3241 }
3242 }
3245 }
3249 /*
3250 * UpdateHeader() - determines the best range of lines to be displayed
3251 * using the global ods value for the current line and the
3252 * top line, also sets ComposerTopLine and pico limits
3253 *
3254 * showtop -- Attempt to show all header lines if they'll fit.
3255 *
3256 * notes:
3257 * This is pretty ugly because it has to keep the current line
3258 * on the screen in a reasonable location no matter what.
3259 * There are also a couple of rules to follow:
3260 * 1) follow paging conventions of pico (ie, half page
3261 * scroll)
3262 * 2) if more than one page, always display last half when
3263 * pline is toward the end of the header
3264 *
3265 * returns:
3266 * TRUE if anything changed (side effects: new p_line, top_l
3267 * top_e, and pico parms)
3268 * FALSE if nothing changed
3269 *
3270 */
3271 int
3273 {
3282 /* NewTop if cur header line is at bottom of screen or two from */
3283 /* the bottom of the screen if cur line is bottom header line */
3286 }
3292 /*
3293 * this checks to make sure cur_l is below top_l and that
3294 * cur_l is on the screen...
3295 */
3300 }
3301 }
3302 }
3310 }
3319 }
3328 }
3330 }
3334 /*
3335 * NewTop() - calculate a new top_l based on the cur_l
3336 *
3337 * showtop -- Attempt to show all the header lines if they'll fit
3338 *
3339 * returns:
3340 * with ods.top_l and top_e pointing at a reasonable line
3341 * entry
3342 */
3343 void
3345 {
3358 }
3359 }
3363 /*
3364 * display_delimiter() - just paint the header/message body delimiter with
3365 * inverse value specified by state.
3366 */
3367 void
3369 {
3379 }
3388 for(delim_ps = 0; bufp[delim_ps] && pscr(ComposerTopLine-1,delim_ps) != NULL && pscr(ComposerTopLine-1,delim_ps)->c == bufp[delim_ps];delim_ps++)
3389 ;
3396 }
3397 }
3419 }
3420 }
3424 /*
3425 * InvertPrompt() - invert the prompt associated with header entry to state
3426 * state (true if invert, false otherwise).
3427 * returns:
3428 * non-zero if nothing done
3429 * 0 if prompt inverted successfully
3430 *
3431 * notes:
3432 * come to think of it, this func and the one above could
3433 * easily be combined
3434 */
3435 int
3437 {
3450 }
3454 /*
3455 * Makes sure that the prompt doesn't take up more than prwid of screen space.
3456 * The caller should do that, too, in order to make it look right so
3457 * this should most likely be a no-op
3458 */
3462 }
3469 ;
3474 else
3479 }
3480 }
3485 else
3487 }
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 }
3668 sbuflen++;
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