| blob | 05b8608a3e63279c8b9284ebec9470568334819b |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2006-2009 University of Washington
8 * Copyright 2013-2015 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 postition */
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 {
2786 }
2798 }
2799 }
2805 }
2811 }
2824 }
2834 }
2835 }
2840 }
2841 curline++;
2847 }
2856 }
2857 }
2860 }
2864 /*
2865 * PaintBody() - generic call to handle repainting everything BUT the
2866 * header
2867 *
2868 * notes:
2869 * The header redrawing in a level 0 body paint gets done
2870 * in update()
2871 */
2872 void
2874 {
2884 }
2885 }
2888 /*
2889 * display_for_send - paint the composer from the top line and return.
2890 */
2891 void
2893 {
2897 /* if first header line isn't displayed, there's work to do */
2905 /*
2906 * fake that the cursor's in the first header line
2907 * and force repaint...
2908 */
2928 /* in case we don't exit, set up restoring the screen */
2930 }
2931 }
2934 /*
2935 * ArrangeHeader - set up display parm such that header is reasonably
2936 * displayed
2937 */
2938 void
2940 {
2951 }
2954 }
2957 /*
2958 * ComposerHelp() - display mail help in a context sensitive way
2959 * based on the level passed ...
2960 */
2961 int
2963 {
2975 }
2986 }
2991 }
2995 /*
2996 * ToggleHeader() - set or unset pico values to the full screen size
2997 * painting header if need be.
2998 */
2999 int
3001 {
3002 /*
3003 * check to see if we need to display the header...
3004 */
3008 }
3010 /*
3011 * set bounds for no header display
3012 */
3015 }
3017 }
3021 /*
3022 * HeaderLen() - return the length in lines of the exposed portion of the
3023 * header
3024 */
3025 int
3027 {
3037 i++;
3038 }
3040 }
3044 /*
3045 * first_hline() - return a pointer to the first displayable header line
3046 *
3047 * returns:
3048 * 1) pointer to first displayable line in header and header
3049 * entry, via side effect, that the first line is a part of
3050 * 2) NULL if no next line, leaving entry at LASTHDR
3051 */
3054 {
3055 /* init *entry so we're sure to start from the top */
3062 }
3065 /*
3066 * first_sel_hline() - return a pointer to the first selectable header line
3067 *
3068 * returns:
3069 * 1) pointer to first selectable line in header and header
3070 * entry, via side effect, that the first line is a part of
3071 * 2) NULL if no next line, leaving entry at LASTHDR
3072 */
3075 {
3076 /* init *entry so we're sure to start from the top */
3083 }
3087 /*
3088 * next_hline() - return a pointer to the next line structure
3089 *
3090 * returns:
3091 * 1) pointer to next displayable line in header and header
3092 * entry, via side effect, that the next line is a part of
3093 * 2) NULL if no next line, leaving entry at LASTHDR
3094 */
3097 {
3105 }
3108 }
3109 else
3111 }
3114 /*
3115 * next_sel_hline() - return a pointer to the next selectable line structure
3116 *
3117 * returns:
3118 * 1) pointer to next selectable line in header and header
3119 * entry, via side effect, that the next line is a part of
3120 * 2) NULL if no next line, leaving entry at LASTHDR
3121 */
3124 {
3132 }
3135 }
3136 else
3138 }
3142 /*
3143 * prev_hline() - return a pointer to the next line structure back
3144 *
3145 * returns:
3146 * 1) pointer to previous displayable line in header and
3147 * the header entry that the next line is a part of
3148 * via side effect
3149 * 2) NULL if no next line, leaving entry unchanged from
3150 * the value it had on entry.
3151 */
3154 {
3168 }
3169 }
3173 }
3174 else
3176 }
3179 /*
3180 * prev_sel_hline() - return a pointer to the previous selectable line
3181 *
3182 * returns:
3183 * 1) pointer to previous selectable line in header and
3184 * the header entry that the next line is a part of
3185 * via side effect
3186 * 2) NULL if no next line, leaving entry unchanged from
3187 * the value it had on entry.
3188 */
3191 {
3205 }
3206 }
3210 }
3211 else
3213 }
3217 /*
3218 * first_requested_hline() - return pointer to first line that pico's caller
3219 * asked that we start on.
3220 */
3223 {
3234 }
3235 }
3238 }
3242 /*
3243 * UpdateHeader() - determines the best range of lines to be displayed
3244 * using the global ods value for the current line and the
3245 * top line, also sets ComposerTopLine and pico limits
3246 *
3247 * showtop -- Attempt to show all header lines if they'll fit.
3248 *
3249 * notes:
3250 * This is pretty ugly because it has to keep the current line
3251 * on the screen in a reasonable location no matter what.
3252 * There are also a couple of rules to follow:
3253 * 1) follow paging conventions of pico (ie, half page
3254 * scroll)
3255 * 2) if more than one page, always display last half when
3256 * pline is toward the end of the header
3257 *
3258 * returns:
3259 * TRUE if anything changed (side effects: new p_line, top_l
3260 * top_e, and pico parms)
3261 * FALSE if nothing changed
3262 *
3263 */
3264 int
3266 {
3275 /* NewTop if cur header line is at bottom of screen or two from */
3276 /* the bottom of the screen if cur line is bottom header line */
3279 }
3285 /*
3286 * this checks to make sure cur_l is below top_l and that
3287 * cur_l is on the screen...
3288 */
3293 }
3294 }
3295 }
3303 }
3312 }
3321 }
3323 }
3327 /*
3328 * NewTop() - calculate a new top_l based on the cur_l
3329 *
3330 * showtop -- Attempt to show all the header lines if they'll fit
3331 *
3332 * returns:
3333 * with ods.top_l and top_e pointing at a reasonable line
3334 * entry
3335 */
3336 void
3338 {
3351 }
3352 }
3356 /*
3357 * display_delimiter() - just paint the header/message body delimiter with
3358 * inverse value specified by state.
3359 */
3360 void
3362 {
3375 for(delim_ps = 0; bufp[delim_ps] && pscr(ComposerTopLine-1,delim_ps) != NULL && pscr(ComposerTopLine-1,delim_ps)->c == bufp[delim_ps];delim_ps++)
3376 ;
3382 }
3383 }
3399 }
3403 /*
3404 * InvertPrompt() - invert the prompt associated with header entry to state
3405 * state (true if invert, false otherwise).
3406 * returns:
3407 * non-zero if nothing done
3408 * 0 if prompt inverted successfully
3409 *
3410 * notes:
3411 * come to think of it, this func and the one above could
3412 * easily be combined
3413 */
3414 int
3416 {
3429 }
3433 /*
3434 * Makes sure that the prompt doesn't take up more than prwid of screen space.
3435 * The caller should do that, too, in order to make it look right so
3436 * this should most likely be a no-op
3437 */
3441 }
3448 ;
3453 else
3458 }
3459 }
3464 else
3466 }
3483 }
3487 /*
3488 * partial_entries() - toggle display of the bcc and fcc fields.
3489 *
3490 * returns:
3491 * TRUE if there are partial entries on the display
3492 * FALSE otherwise.
3493 */
3494 int
3496 {
3500 /*---- find out status of first rich header ---*/
3502 ;
3510 }
3514 /*
3515 * entry_line() - return the physical line on the screen associated
3516 * with the given header entry field. Note: the field
3517 * may span lines, so if the last char is set, return
3518 * the appropriate value.
3519 *
3520 * returns:
3521 * 1) physical line number of entry
3522 * 2) -1 if entry currently not on display
3523 */
3524 int
3526 {
3533 p_line++){
3540 }
3543 else
3545 }
3547 }
3549 }
3553 /*
3554 * physical_line() - return the physical line on the screen associated
3555 * with the given header line pointer.
3556 *
3557 * returns:
3558 * 1) physical line number of entry
3559 * 2) -1 if entry currently not on display
3560 */
3561 int
3563 {
3576 }
3578 }
3582 /*
3583 * call_builder() - resolve any nicknames in the address book associated
3584 * with the given entry...
3585 *
3586 * NOTES:
3587 *
3588 * BEWARE: this function can cause cur_l and top_l to get lost so BE
3589 * CAREFUL before and after you call this function!!!
3590 *
3591 * There could to be something here to resolve cur_l and top_l
3592 * reasonably into the new linked list for this entry.
3593 *
3594 * The reason this would mostly work without it is resolve_niks gets
3595 * called for the most part in between fields. Since we're moving
3596 * to the beginning or end (i.e. the next/prev pointer in the old
3597 * freed cur_l is NULL) of the next entry, we get a new cur_l
3598 * pointing at a good line. Then since top_l is based on cur_l in
3599 * NewTop() we have pretty much lucked out.
3600 *
3601 * Where we could get burned is in a canceled exit (ctrl|x). Here
3602 * nicknames get resolved into addresses, which invalidates cur_l
3603 * and top_l. Since we don't actually leave, we could begin editing
3604 * again with bad pointers. This would usually results in a nice
3605 * core dump.
3606 *
3607 * NOTE: The mangled argument is a little strange. It's used on both
3608 * input and output. On input, if it is not set, then that tells the
3609 * builder not to do anything that might take a long time, like a
3610 * white pages lookup. On return, it tells the caller that the screen
3611 * and signals may have been mangled so signals should be reset, window
3612 * resized, and screen redrawn.
3613 *
3614 * RETURNS:
3615 * > 0 if any names where resolved, otherwise
3616 * 0 if not, or
3617 * < 0 on error
3618 * -1: move to next line
3619 * -2: don't move off this line
3620 */
3621 int
3623 {
3644 }
3649 }
3653 /*
3654 * cat the whole entry into one string...
3655 */
3660 /*
3661 * To keep pine address builder happy, addresses should be separated
3662 * by ", ". Add this space if needed, otherwise...
3663 * (This is some ancient requirement that is no longer needed.)
3664 *
3665 * If this line is NOT a continuation of the previous line, add
3666 * white space for pine's address builder if its not already there...
3667 * (This is some ancient requirement that is no longer needed.)
3668 *
3669 * Also if it's not a continuation (i.e., there's already and addr on
3670 * the line), and there's another line below, treat the new line as
3671 * an implied comma.
3672 * (This should only be done for address-type lines, not for regular
3673 * text lines like subjects. Key off of the break_on_comma bit which
3674 * should only be set on those that won't mind a comma being added.)
3675 */
3687 }
3692 }
3693 }
3699 }
3700 }
3701 }
3708 }
3711 }
3714 /* check if any non-sticky affected entries */
3719 /* there is at least one non-sticky so make a list to pass */
3727 }
3733 }
3734 }
3740 }
3748 }
3749 }
3754 }
3755 }
3756 }
3757 }
3759 /*
3760 * Even if there are no affected entries, we still need the arg
3761 * to pass the "me" pointer.
3762 */
3768 }
3774 }
3775 }
3777 /*
3778 * The builder may make a new call back to pico() so we save and
3779 * restore the pico state.
3780 */
3786 }
3792 }
3798 }
3807 }
3810 e;
3816 /* make sure they see it if changed */
3825 }
3829 }
3830 }
3831 }
3837 /* Don't free xtra or me, they just point to headerentry data */
3843 }
3847 }
3850 void
3852 {
3860 /*
3861 * Since expander may make a call back to pico() we need to
3862 * save and restore pico state.
3863 */
3878 /*
3879 * Use tbuf to cat together multiple line entries before comparing.
3880 */
3887 e++;
3897 }
3898 }
3904 }
3913 }
3914 }
3922 /*
3923 * If any of the lines for this entry are current or
3924 * top, fix that.
3925 */
3932 }
3935 }
3936 }
3939 }
3948 }
3949 }
3952 }
3955 /*
3956 * strend - neglecting white space, returns TRUE if c is at the
3957 * end of the given line. otherwise FALSE.
3958 */
3959 int
3961 {
3970 }
3973 }
3976 /*
3977 * ucs4_strqchr - returns pointer to first non-quote-enclosed occurance of ch in
3978 * the given string. otherwise NULL.
3979 * s -- the string
3980 * ch -- the character we're looking for
3981 * q -- q tells us if we start out inside quotes on entry and is set
3982 * correctly on exit.
3983 * m -- max characters we'll check for ch (set to -1 for no max)
3984 */
3985 UCS *
3987 {
3995 }
3999 }
4002 }
4005 /*
4006 * KillHeaderLine() - kill a line in the header
4007 *
4008 * notes:
4009 * This is pretty simple. Just using the emacs kill buffer
4010 * and its accompanying functions to cut the text from lines.
4011 *
4012 * returns:
4013 * TRUE if hldelete worked
4014 * FALSE otherwise
4015 */
4016 int
4018 {
4030 /*put to be deleted part into kill buffer */
4036 }
4041 #ifdef _WINDOWS
4043 #endif
4057 }
4061 }
4072 }
4073 }
4077 /*
4078 * SaveHeaderLines() - insert the saved lines in the list before the
4079 * current line in the header
4080 *
4081 * notes:
4082 * Once again, just using emacs' kill buffer and its
4083 * functions.
4084 *
4085 * returns:
4086 * TRUE if something good happend
4087 * FALSE otherwise
4088 */
4089 int
4091 {
4104 }
4105 }
4106 else
4121 }
4122 }
4126 }
4127 }
4129 }
4131 /* insert new text at the dot position */
4139 }
4155 /* insert text in HLSZ character chunks */
4174 /*
4175 * This comes after the break above because it will
4176 * be accounted for in the while loop below.
4177 */
4181 else
4183 }
4186 }
4190 }
4191 }
4193 /* insert the remainder of text */
4210 else
4212 }
4219 }
4228 }
4229 }
4230 }
4234 }
4238 /*
4239 * break_point - Break the given line at the most reasonable character breakch
4240 * within maxwid max characters.
4241 *
4242 * returns:
4243 * Pointer to the best break point in s, or
4244 * Pointer to the beginning of s if no break point found
4245 */
4246 UCS *
4248 {
4252 /*
4253 * Start at maxwid and work back until first opportunity to break.
4254 */
4257 /*
4258 * Quoted should be set up for the start of line. Since we want
4259 * to move to bp and work our way back we need to scan through the
4260 * line up to bp setting quoted appropriately.
4261 */
4276 }
4277 }
4279 /*
4280 * if break char isn't a space, leave a space after
4281 * the break char.
4282 */
4287 }
4288 }
4289 }
4291 bp--;
4292 }
4298 }
4303 /*
4304 * hldelete() - remove the header line pointed to by l from the linked list
4305 * of lines.
4306 *
4307 * notes:
4308 * the case of first line in field is kind of bogus. since
4309 * the array of headers has a pointer to the first line, and
4310 * i don't want to worry about this too much, i just copied
4311 * the line below and removed it rather than the first one
4312 * from the list.
4313 *
4314 * returns:
4315 * TRUE if it worked
4316 * FALSE otherwise
4317 */
4318 int
4320 {
4329 }
4332 }
4340 }
4344 }
4350 }
4354 /*
4355 * is_blank - returns true if the next n chars from coordinates row, col
4356 * on display are spaces
4357 */
4358 int
4360 {
4365 }
4367 }
4370 /*
4371 * ShowPrompt - display key help corresponding to the current header entry
4372 */
4373 void
4375 {
4380 }
4381 else
4388 else
4395 }
4400 }
4405 }
4408 }
4412 }
4418 }
4419 else
4423 }
4429 }
4432 }
4435 /*
4436 * packheader - packup all of the header fields for return to caller.
4437 * NOTE: all of the header info passed in, including address
4438 * of the pointer to each string is contained in the
4439 * header entry array "headents".
4440 */
4441 int
4443 {
4455 #ifdef ATTACHMENTS
4456 /*
4457 * attachments are special case, already in struct we pass back
4458 */
4460 i++;
4462 }
4463 #endif
4466 i++;
4468 }
4470 /*
4471 * count chars to see if we need a new malloc'd space for our
4472 * array.
4473 */
4477 /*
4478 * add one for possible concatination of a ' ' character ...
4479 */
4484 count++;
4487 }
4490 }
4495 }
4497 /*
4498 * don't forget to include space for the null terminator!!!!
4499 */
4506 }
4510 }
4511 }
4518 /* pass the cursor offset back in Pmaster struct */
4521 saw_current_line++;
4522 else
4524 }
4534 }
4537 }
4540 }
4541 }
4543 i++;
4544 }
4547 }
4551 /*
4552 * zotheader - free all malloc'd lines associated with the header structs
4553 */
4554 void
4556 {
4561 }
4564 /*
4565 * zotentry - free malloc'd space associated with the given linked list
4566 */
4567 void
4569 {
4576 }
4577 }
4581 /*
4582 * zotcomma - blast any trailing commas and white space from the end
4583 * of the given line
4584 */
4585 int
4587 {
4597 }
4600 }
4601 }
4604 }
4607 /*
4608 * Save the current state of global variables so that we can restore
4609 * them later. This is so we can call pico again.
4610 * Also have to initialize some variables that normally would be set to
4611 * zero on startup.
4612 */
4613 VARS_TO_SAVE *
4615 {
4667 /* Initialize for next pico call */
4674 }
4677 void
4679 {
4723 }
4731 }
4734 void
4736 {
4744 }
4747 /*
4748 * Ok to call this twice in a row because it won't do anything the second
4749 * time.
4750 */
4751 void
4753 {
4759 }
4768 }
4769 else
4774 }
4775 }
4778 /*
4779 * What is this for?
4780 * This is so that the To line will be appended to by an Lcc
4781 * entry unless the user types in the To line after the Lcc
4782 * has already been set.
4783 */
4784 void
4786 {
4789 }
4792 #ifdef MOUSE
4793 #undef HeaderEditor
4795 /*
4796 * Wraper function for the real header editor.
4797 * Does the important tasks of:
4798 * 1) verifying that we _can_ edit the headers.
4799 * 2) acting on the result code from the header editor.
4800 */
4801 int
4803 {
4807 #ifdef _WINDOWS
4808 /* Sometimes we get here from a scroll callback, which
4809 * is no good at all because mswin is not ready to process input and
4810 * this _headeredit() will never do anything.
4811 * Putting this test here was the most general solution I could think
4812 * of. */
4815 #endif
4820 }
4822 }
4823 #endif