diff options
Diffstat (limited to 'pith/mailindx.c')
| -rw-r--r-- | pith/mailindx.c | 6434 |
1 files changed, 6434 insertions, 0 deletions
diff --git a/pith/mailindx.c b/pith/mailindx.c new file mode 100644 index 00000000..f3b68bfb --- /dev/null +++ b/pith/mailindx.c @@ -0,0 +1,6434 @@ +#if !defined(lint) && !defined(DOS) +static char rcsid[] = "$Id: mailindx.c 1266 2009-07-14 18:39:12Z hubert@u.washington.edu $"; +#endif + +/* ======================================================================== + * Copyright 2006-2008 University of Washington + * Copyright 2013 Eduardo Chappa + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * ======================================================================== + */ + +#include "../pith/headers.h" +#include "../pith/mailindx.h" +#include "../pith/mailview.h" +#include "../pith/flag.h" +#include "../pith/icache.h" +#include "../pith/msgno.h" +#include "../pith/thread.h" +#include "../pith/strlst.h" +#include "../pith/status.h" +#include "../pith/mailcmd.h" +#include "../pith/search.h" +#include "../pith/charset.h" +#include "../pith/reply.h" +#include "../pith/bldaddr.h" +#include "../pith/addrstring.h" +#include "../pith/news.h" +#include "../pith/util.h" +#include "../pith/pattern.h" +#include "../pith/sequence.h" +#include "../pith/color.h" +#include "../pith/stream.h" +#include "../pith/string.h" +#include "../pith/send.h" +#include "../pith/options.h" +#include "../pith/ablookup.h" +#ifdef _WINDOWS +#include "../pico/osdep/mswin.h" +#endif + +/* + * pointers to formatting functions + */ +ICE_S *(*format_index_line)(INDEXDATA_S *); +void (*setup_header_widths)(MAILSTREAM *); + +/* + * pointer to optional load_overview functionality + */ +void (*pith_opt_paint_index_hline)(MAILSTREAM *, long, ICE_S *); + +/* + * pointer to hook for saving index format state + */ +void (*pith_opt_save_index_state)(int); + +/* + * hook to allow caller to insert cue that indicates a condensed + * thread relationship cue + */ +int (*pith_opt_condense_thread_cue)(PINETHRD_S *, ICE_S *, char **, size_t *, int, int); +int (*pith_opt_truncate_sfstr)(void); + + +/* + * Internal prototypes + */ +void setup_for_thread_index_screen(void); +ICE_S *format_index_index_line(INDEXDATA_S *); +ICE_S *format_thread_index_line(INDEXDATA_S *); +int set_index_addr(INDEXDATA_S *, char *, ADDRESS *, char *, int, char *); +int ctype_is_fixed_length(IndexColType); +void setup_index_header_widths(MAILSTREAM *); +void setup_thread_header_widths(MAILSTREAM *); +int parse_index_format(char *, INDEX_COL_S **); +int index_in_overview(MAILSTREAM *); +ADDRESS *fetch_from(INDEXDATA_S *); +ADDRESS *fetch_sender(INDEXDATA_S *); +char *fetch_newsgroups(INDEXDATA_S *); +char *fetch_subject(INDEXDATA_S *); +char *fetch_date(INDEXDATA_S *); +long fetch_size(INDEXDATA_S *); +BODY *fetch_body(INDEXDATA_S *); +char *fetch_firsttext(INDEXDATA_S *idata, int); +char *fetch_header(INDEXDATA_S *idata, char *hdrname); +void subj_str(INDEXDATA_S *, char *, size_t, SubjKW, int, ICE_S *); +void key_str(INDEXDATA_S *, SubjKW, ICE_S *); +void header_str(INDEXDATA_S *, HEADER_TOK_S *, ICE_S *); +void prio_str(INDEXDATA_S *, IndexColType, ICE_S *); +void from_str(IndexColType, INDEXDATA_S *, char *, size_t, ICE_S *); +int day_of_week(struct date *); +int day_of_year(struct date *); +unsigned long ice_hash(ICE_S *); +char *left_adjust(int); +char *right_adjust(int); +char *format_str(int, int); +char *copy_format_str(int, int, char *, int); +void set_print_format(IELEM_S *, int, int); +void set_ielem_widths_in_field(IFIELD_S *); + + +#define BIGWIDTH 2047 + + +/*---------------------------------------------------------------------- + Initialize the index_disp_format array in ps_global from this + format string. + + Args: format -- the string containing the format tokens + answer -- put the answer here, free first if there was a previous + value here + ----*/ +void +init_index_format(char *format, INDEX_COL_S **answer) +{ + char *p; + int i, w, monabb_width = 0, column = 0; + + /* + * Record the fact that SCORE appears in some index format. This + * is a heavy-handed approach. It will stick at 1 if any format ever + * contains score during this session. This is ok since it will just + * cause recalculation if wrong and these things rarely change much. + */ + if(!ps_global->a_format_contains_score && format + && strstr(format, "SCORE")){ + ps_global->a_format_contains_score = 1; + /* recalculate need for scores */ + scores_are_used(SCOREUSE_INVALID); + } + + set_need_format_setup(ps_global->mail_stream); + /* if custom format is specified, try it, else go with default */ + if(!(format && *format && parse_index_format(format, answer))){ + static INDEX_COL_S answer_default[] = { + {iStatus, Fixed, 3}, + {iMessNo, WeCalculate}, + {iSDateTime24, WeCalculate}, + {iFromTo, Percent, 33}, /* percent of rest */ + {iSizeNarrow, WeCalculate}, + {iSubjKey, Percent, 67}, + {iNothing} + }; + + if(*answer) + free_index_format(answer); + + *answer = (INDEX_COL_S *)fs_get(sizeof(answer_default)); + memcpy(*answer, answer_default, sizeof(answer_default)); + } + + /* + * Test to see how long the month abbreviations are. + */ + for(i = 1; i <= 12; i++){ + p = month_abbrev_locale(i); + monabb_width = MAX(utf8_width(p), monabb_width); + } + + monabb_width = MIN(MAX(2, monabb_width), 5); + + /* + * Fill in req_width's for WeCalculate items. + */ + for(column = 0; (*answer)[column].ctype != iNothing; column++){ + + /* don't use strftime if we're not trying to use the LC_TIME stuff */ + if(F_ON(F_DISABLE_INDEX_LOCALE_DATES, ps_global)){ + switch((*answer)[column].ctype){ + case iSDate: + (*answer)[column].ctype = iS1Date; + break; + case iSDateTime: + (*answer)[column].ctype = iSDateTimeS1; + break; + case iSDateTime24: + (*answer)[column].ctype = iSDateTimeS124; + break; + default: + break; + } + } + + if((*answer)[column].wtype == WeCalculate){ + switch((*answer)[column].ctype){ + case iPrio: + case iPrioBang: + case iAtt: + (*answer)[column].req_width = 1; + break; + case iYear2Digit: + case iDay: + case iMon: + case iDay2Digit: + case iMon2Digit: + case iArrow: + case iKeyInit: + (*answer)[column].req_width = 2; + break; + case iStatus: + case iMessNo: + case iInit: + (*answer)[column].req_width = 3; + break; + case iYear: + case iDayOrdinal: + case iSIStatus: + (*answer)[column].req_width = 4; + break; + case iTime24: + case iTimezone: + case iSizeNarrow: + case iKey: + (*answer)[column].req_width = 5; + break; + case iFStatus: + case iIStatus: + case iScore: + (*answer)[column].req_width = 6; + break; + case iTime12: + case iSTime: + case iKSize: + case iSize: + case iPrioAlpha: + (*answer)[column].req_width = 7; + break; + case iS1Date: + case iS2Date: + case iS3Date: + case iS4Date: + case iDateIsoS: + case iSizeComma: + (*answer)[column].req_width = 8; + break; + case iMonAbb: + (*answer)[column].req_width = monabb_width; + (*answer)[column].monabb_width = monabb_width; + break; + case iDayOfWeekAbb: + { + w = 0; + + /* + * Test to see how long it is. + */ + for(i = 0; i < 7; i++){ + p = day_abbrev_locale(i); + w = MAX(utf8_width(p), w); + } + + (*answer)[column].req_width = MIN(MAX(2, w), 5); + } + break; + case iDate: + (*answer)[column].req_width = monabb_width + 3; + (*answer)[column].monabb_width = monabb_width; + break; + case iMonLong: + { + w = 0; + + /* + * Test to see how long it is. + */ + for(i = 1; i <= 12; i++){ + p = month_name_locale(i); + w = MAX(utf8_width(p), w); + } + + (*answer)[column].req_width = MIN(MAX(3, w), 12); + } + break; + case iDayOfWeek: + { + w = 0; + + for(i = 0; i < 7; i++){ + p = day_name_locale(i); + w = MAX(utf8_width(p), w); + } + + (*answer)[column].req_width = MIN(MAX(3, w), 12); + } + break; + case iSDate: + case iSDateTime: + case iSDateTime24: + case iPrefDate: + case iPrefTime: + case iPrefDateTime: + { + /* + * Format a date to see how long it is. + * Make it as least as long as "Yesterday". + * We should really use the width of the longest + * of the translated yesterdays and friends but... + */ + struct tm tm; + int len = 20; + char ss[100]; + + memset(&tm, 0, sizeof(tm)); + tm.tm_year = 106; + tm.tm_mon = 11; + tm.tm_mday = 31; + tm.tm_hour = 3; + tm.tm_min = 23; + tm.tm_wday = 3; + switch((*answer)[column].ctype){ + case iPrefTime: + our_strftime(ss, sizeof(ss), "%X", &tm); + break; + case iPrefDateTime: + our_strftime(ss, sizeof(ss), "%c", &tm); + len = 32; + break; + default: + our_strftime(ss, sizeof(ss), "%x", &tm); + break; + } + (*answer)[column].req_width = MIN(MAX(9, utf8_width(ss)), len); + } + + (*answer)[column].monabb_width = monabb_width; + break; + + case iDescripSize: + case iSDateIsoS: + case iSDateS1: case iSDateS2: case iSDateS3: case iSDateS4: + case iSDateTimeIsoS: + case iSDateTimeS1: case iSDateTimeS2: case iSDateTimeS3: case iSDateTimeS4: + case iSDateTimeIsoS24: + case iSDateTimeS124: case iSDateTimeS224: case iSDateTimeS324: case iSDateTimeS424: + /* + * These SDates are 8 wide but they need to be 9 for "Yesterday". + */ + (*answer)[column].req_width = 9; + break; + case iDateIso: + case iSDateIso: case iSDateTimeIso: case iSDateTimeIso24: + (*answer)[column].req_width = 10; + break; + case iLDate: + (*answer)[column].req_width = 12; + (*answer)[column].monabb_width = monabb_width; + break; + case iRDate: + (*answer)[column].req_width = 16; + break; + default: + break; + } + } + } + + calc_extra_hdrs(); + if(get_extra_hdrs()) + (void) mail_parameters(NULL, SET_IMAPEXTRAHEADERS, + (void *) get_extra_hdrs()); +} + + +void +reset_index_format(void) +{ + long rflags = ROLE_DO_OTHER; + PAT_STATE pstate; + PAT_S *pat; + int we_set_it = 0; + + if(ps_global->mail_stream && nonempty_patterns(rflags, &pstate)){ + for(pat = first_pattern(&pstate); pat; pat = next_pattern(&pstate)){ + if(match_pattern(pat->patgrp, ps_global->mail_stream, NULL, + NULL, NULL, SE_NOSERVER|SE_NOPREFETCH)) + break; + } + + if(pat && pat->action && !pat->action->bogus + && pat->action->index_format){ + we_set_it++; + init_index_format(pat->action->index_format, + &ps_global->index_disp_format); + } + } + + if(!we_set_it) + init_index_format(ps_global->VAR_INDEX_FORMAT, + &ps_global->index_disp_format); +} + + +void +free_index_format(INDEX_COL_S **disp_format) +{ + INDEX_COL_S *cdesc = NULL; + + if(disp_format && *disp_format){ + for(cdesc = (*disp_format); cdesc->ctype != iNothing; cdesc++) + if(cdesc->hdrtok) + free_hdrtok(&cdesc->hdrtok); + + fs_give((void **) disp_format); + } +} + + +HEADER_TOK_S * +new_hdrtok(char *hdrname) +{ + HEADER_TOK_S *hdrtok; + + hdrtok = (HEADER_TOK_S *) fs_get(sizeof(HEADER_TOK_S)); + memset(hdrtok, 0, sizeof(HEADER_TOK_S)); + hdrtok->hdrname = hdrname ? cpystr(hdrname) : NULL; + hdrtok->fieldnum = 0; + hdrtok->adjustment = Left; + hdrtok->fieldsepcnt = 1; + hdrtok->fieldseps = cpystr(" "); + + return(hdrtok); +} + + +void +free_hdrtok(HEADER_TOK_S **hdrtok) +{ + if(hdrtok && *hdrtok){ + if((*hdrtok)->hdrname) + fs_give((void **) &(*hdrtok)->hdrname); + + if((*hdrtok)->fieldseps) + fs_give((void **) &(*hdrtok)->fieldseps); + + fs_give((void **) hdrtok); + } +} + + +/* popular ones first to make it slightly faster */ +static INDEX_PARSE_T itokens[] = { + {"STATUS", iStatus, FOR_INDEX}, + {"MSGNO", iMessNo, FOR_INDEX}, + {"DATE", iDate, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"FROMORTO", iFromTo, FOR_INDEX}, + {"FROMORTONOTNEWS", iFromToNotNews, FOR_INDEX}, + {"SIZE", iSize, FOR_INDEX}, + {"SIZECOMMA", iSizeComma, FOR_INDEX}, + {"SIZENARROW", iSizeNarrow, FOR_INDEX}, + {"KSIZE", iKSize, FOR_INDEX}, + {"SUBJECT", iSubject, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"FULLSTATUS", iFStatus, FOR_INDEX}, + {"IMAPSTATUS", iIStatus, FOR_INDEX}, + {"SHORTIMAPSTATUS", iSIStatus, FOR_INDEX}, + {"SUBJKEY", iSubjKey, FOR_INDEX}, + {"SUBJKEYINIT", iSubjKeyInit, FOR_INDEX}, + {"SUBJECTTEXT", iSubjectText, FOR_INDEX}, + {"SUBJKEYTEXT", iSubjKeyText, FOR_INDEX}, + {"SUBJKEYINITTEXT", iSubjKeyInitText, FOR_INDEX}, + {"OPENINGTEXT", iOpeningText, FOR_INDEX}, + {"OPENINGTEXTNQ", iOpeningTextNQ, FOR_INDEX}, + {"KEY", iKey, FOR_INDEX}, + {"KEYINIT", iKeyInit, FOR_INDEX}, + {"DESCRIPSIZE", iDescripSize, FOR_INDEX}, + {"ATT", iAtt, FOR_INDEX}, + {"SCORE", iScore, FOR_INDEX}, + {"PRIORITY", iPrio, FOR_INDEX}, + {"PRIORITYALPHA", iPrioAlpha, FOR_INDEX}, + {"PRIORITY!", iPrioBang, FOR_INDEX}, + {"LONGDATE", iLDate, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SHORTDATE1", iS1Date, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SHORTDATE2", iS2Date, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SHORTDATE3", iS3Date, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SHORTDATE4", iS4Date, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"DATEISO", iDateIso, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SHORTDATEISO", iDateIsoS, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATE", iSDate, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTTIME", iSTime, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATEISO", iSDateIso, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATESHORTISO",iSDateIsoS, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATES1", iSDateS1, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATES2", iSDateS2, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATES3", iSDateS3, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATES4", iSDateS4, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIME", iSDateTime, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMEISO",iSDateTimeIso, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMESHORTISO",iSDateTimeIsoS,FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMES1", iSDateTimeS1, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMES2", iSDateTimeS2, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMES3", iSDateTimeS3, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMES4", iSDateTimeS4, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIME24", iSDateTime24, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMEISO24", iSDateTimeIso24,FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMESHORTISO24",iSDateTimeIsoS24,FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMES124", iSDateTimeS124, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMES224", iSDateTimeS224, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMES324", iSDateTimeS324, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SMARTDATETIMES424", iSDateTimeS424, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"TIME24", iTime24, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"TIME12", iTime12, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"TIMEZONE", iTimezone, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"MONTHABBREV", iMonAbb, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"DAYOFWEEKABBREV", iDayOfWeekAbb, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"DAYOFWEEK", iDayOfWeek, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"FROM", iFrom, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"TO", iTo, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"SENDER", iSender, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"CC", iCc, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"RECIPS", iRecips, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"NEWS", iNews, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"TOANDNEWS", iToAndNews, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"NEWSANDTO", iNewsAndTo, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"RECIPSANDNEWS", iRecipsAndNews, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"NEWSANDRECIPS", iNewsAndRecips, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"MSGID", iMsgID, FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"CURNEWS", iCurNews, FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"DAYDATE", iRDate, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"PREFDATE", iPrefDate, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"PREFTIME", iPrefTime, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"PREFDATETIME", iPrefDateTime, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"DAY", iDay, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"DAYORDINAL", iDayOrdinal, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"DAY2DIGIT", iDay2Digit, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"MONTHLONG", iMonLong, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"MONTH", iMon, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"MONTH2DIGIT", iMon2Digit, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"YEAR", iYear, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"YEAR2DIGIT", iYear2Digit, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"ADDRESS", iAddress, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"MAILBOX", iMailbox, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"ROLENICK", iRoleNick, FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"INIT", iInit, FOR_INDEX|FOR_REPLY_INTRO|FOR_TEMPLATE}, + {"CURDATE", iCurDate, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURDATEISO", iCurDateIso, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURDATEISOS", iCurDateIsoS, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURTIME24", iCurTime24, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURTIME12", iCurTime12, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURDAY", iCurDay, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURDAY2DIGIT", iCurDay2Digit, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURDAYOFWEEK", iCurDayOfWeek, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURDAYOFWEEKABBREV", iCurDayOfWeekAbb, + FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURMONTH", iCurMon, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURMONTH2DIGIT", iCurMon2Digit, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURMONTHLONG", iCurMonLong, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURMONTHABBREV", iCurMonAbb, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURYEAR", iCurYear, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURYEAR2DIGIT", iCurYear2Digit, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURPREFDATE", iCurPrefDate, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURPREFTIME", iCurPrefTime, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"CURPREFDATETIME", iCurPrefDateTime, + FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"LASTMONTH", iLstMon, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"LASTMONTH2DIGIT", iLstMon2Digit, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"LASTMONTHLONG", iLstMonLong, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"LASTMONTHABBREV", iLstMonAbb, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"LASTMONTHYEAR", iLstMonYear, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"LASTMONTHYEAR2DIGIT", iLstMonYear2Digit, + FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"LASTYEAR", iLstYear, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"LASTYEAR2DIGIT", iLstYear2Digit, FOR_REPLY_INTRO|FOR_TEMPLATE|FOR_FILT}, + {"HEADER", iHeader, FOR_INDEX}, + {"TEXT", iText, FOR_INDEX}, + {"ARROW", iArrow, FOR_INDEX}, + {"NEWLINE", iNewLine, FOR_REPLY_INTRO}, + {"CURSORPOS", iCursorPos, FOR_TEMPLATE}, + {NULL, iNothing, FOR_NOTHING} +}; + +INDEX_PARSE_T * +itoken(int i) +{ + return((i < sizeof(itokens) && itokens[i].name) ? &itokens[i] : NULL); +} + + +/* + * Args txt -- The token being checked begins at the beginning + * of txt. The end of the token is delimited by a null, or + * white space, or an underscore if DELIM_USCORE is set, + * or a left paren if DELIM_PAREN is set. + * flags -- Flags contains the what_for value, and DELIM_ values. + * + * Returns A ptr to an INDEX_PARSE_T from itokens above, else NULL. + */ +INDEX_PARSE_T * +itoktype(char *txt, int flags) +{ + INDEX_PARSE_T *pt; + char token[100 + 1]; + char *v, *w; + + /* + * Separate a copy of the possible token out of txt. + */ + v = txt; + w = token; + while(w < token+sizeof(token)-1 && + *v && + !(!(*v & 0x80) && isspace((unsigned char)*v)) && + !(flags & DELIM_USCORE && *v == '_') && + !(flags & DELIM_PAREN && *v == '(') && + !(flags & DELIM_COLON && *v == ':')) + *w++ = *v++; + + *w = '\0'; + + for(pt = itokens; pt->name; pt++) + if(pt->what_for & flags && !strucmp(pt->name, token)) + return(pt); + + return(NULL); +} + + +int +parse_index_format(char *format_str, INDEX_COL_S **answer) +{ + int i, column = 0; + char *p, *q; + INDEX_PARSE_T *pt; + INDEX_COL_S cdesc[200]; /* plenty of temp storage for answer */ + + memset((void *)cdesc, 0, sizeof(cdesc)); + + p = format_str; + while(p && *p && column < 200-1){ + /* skip leading white space for next word */ + p = skip_white_space(p); + pt = itoktype(p, FOR_INDEX | DELIM_PAREN | DELIM_COLON); + + /* ignore unrecognized word */ + if(!pt){ + for(q = p; *p && !isspace((unsigned char)*p); p++) + ; + + if(*p) + *p++ = '\0'; + + dprint((1, + "parse_index_format: unrecognized token: %s\n", + q ? q : "?")); + q_status_message1(SM_ORDER | SM_DING, 0, 3, + _("Unrecognized word in index-format: %s"), q); + continue; + } + + cdesc[column].ctype = pt->ctype; + + if(pt->ctype == iHeader || pt->ctype == iText){ + /* + * iHeader field has special syntax. + * + * HEADER:hdrname(width,fieldnum,field_separators,L_or_R) + * + * where width is the regular width or percentage width or + * left out for default width, fieldnum defaults to 0 for + * whole thing, 1 for first field, ... + * and field_separators is a list of characters which separate + * the fields. The whole parenthesized part is optional. If used + * the arguments can be dropped from the right, so + * + * HEADER:hdrname or + * HEADER:hdrname(10) or + * HEADER:hdrname(10%) or + * HEADER:hdrname(10,2) or + * HEADER:hdrname(,2) or + * HEADER:hdrname(10,2, ) or + * HEADER:hdrname(10,2,\,:) or + * HEADER:hdrname(10,2,\,:,R) + * + * iText field uses the hdrtok field for convenience. It has syntax + * + * TEXT:text or + * TEXT:text(10) or + * TEXT:text(10%) + * + * and the literal text goes into the index line. It is also special + * because there is no 1 column space after this field. + */ + + /* skip over name */ + p += strlen(pt->name); + + /* look for header name */ + if(*p == ':'){ + char *w, hdrname[200]; + + hdrname[0] = '\0'; + w = hdrname; + p++; + if(*p == '\"'){ /* quoted name */ + p++; + while(w < hdrname + sizeof(hdrname)-1 && *p != '\"'){ + if(*p == '\\') + p++; + + *w++ = *p++; + } + + *w = '\0'; + if(*p == '\"') + p++; + } + else{ + while(w < hdrname + sizeof(hdrname)-1 && + !(!(*p & 0x80) && isspace((unsigned char)*p)) && + *p != '(') + *w++ = *p++; + + *w = '\0'; + } + + if(hdrname[0]){ + cdesc[column].hdrtok = new_hdrtok(hdrname); + } + else{ + if(pt->ctype == iHeader){ + dprint((1, "parse_index_token: HEADER should be followed by :hdrname\n")); + q_status_message(SM_ORDER | SM_DING, 0, 3, "index token HEADER should be followed by :hdrname"); + } + else{ + dprint((1, "parse_index_token: TEXT should be followed by :text\n")); + q_status_message(SM_ORDER | SM_DING, 0, 3, "index token TEXT should be followed by :text"); + } + } + } + else{ + if(pt->ctype == iHeader){ + dprint((1, "parse_index_token: HEADER should be followed by :hdrname, not %s\n", p)); + q_status_message(SM_ORDER | SM_DING, 0, 3, "index token HEADER should be followed by :hdrname"); + } + else{ + dprint((1, "parse_index_token: TEXT should be followed by :text, not %s\n", p)); + q_status_message(SM_ORDER | SM_DING, 0, 3, "index token TEXT should be followed by :text"); + } + + /* skip over rest of bogus config */ + while(!(!(*p & 0x80) && isspace((unsigned char)*p)) && *p != '(') + p++; + } + } + else{ + /* skip over name and look for parens */ + p += strlen(pt->name); + } + + if(*p == '('){ + p++; + q = p; + while(p && *p && isdigit((unsigned char) *p)) + p++; + + if(pt->ctype == iHeader){ + /* first argument is width or width percentage, like for others */ + if(p && *p && (*p == ')' || *p == ',')){ + if(p > q){ + cdesc[column].wtype = Fixed; + cdesc[column].req_width = atoi(q); + } + else{ + cdesc[column].wtype = WeCalculate; + cdesc[column].req_width = 0; + } + } + else if(p && *p && *p == '%' && p > q){ + cdesc[column].wtype = Percent; + cdesc[column].req_width = atoi(q); + p++; + } + else{ + cdesc[column].wtype = WeCalculate; + cdesc[column].req_width = 0; + } + + /* optional 2nd argument is field number, 0 whole thing, 1, 2, ... */ + if(p && *p && *p == ','){ + p++; + /* no space allowed between arguments */ + if(*p && isdigit((unsigned char) *p)){ + q = p; + while(*p && isdigit((unsigned char) *p)) + p++; + + cdesc[column].hdrtok->fieldnum = atoi(q); + + /* + * Optional 3rd argument is field separators. + * Comma is \, and backslash is \\. + */ + if(*p == ','){ + int j; + + p++; + /* don't use default */ + if(*p && *p != ')' && *p != ',' && cdesc[column].hdrtok->fieldseps) + cdesc[column].hdrtok->fieldseps[0] = '\0'; + + j = 0; + if(*p == '\"' && strchr(p+1, '\"')){ + p++; + while(*p && *p != ')' && *p != '\"' && *p != ','){ + if(cdesc[column].hdrtok->fieldseps) + fs_resize((void **) &cdesc[column].hdrtok->fieldseps, j+2); + + if(*p == '\\' && *(p+1)) + p++; + + if(cdesc[column].hdrtok->fieldseps){ + cdesc[column].hdrtok->fieldseps[j++] = *p++; + cdesc[column].hdrtok->fieldseps[j] = '\0'; + cdesc[column].hdrtok->fieldsepcnt = j; + } + } + + if(*p == '\"') + p++; + } + else{ + while(*p && *p != ')' && *p != ','){ + if(cdesc[column].hdrtok->fieldseps) + fs_resize((void **) &cdesc[column].hdrtok->fieldseps, j+2); + if(*p == '\\' && *(p+1)) + p++; + + if(cdesc[column].hdrtok->fieldseps){ + cdesc[column].hdrtok->fieldseps[j++] = *p++; + cdesc[column].hdrtok->fieldseps[j] = '\0'; + cdesc[column].hdrtok->fieldsepcnt = j; + } + } + } + + /* optional 4th argument, left or right adjust */ + if(*p == ','){ + p++; + if(*p == 'L' || *p == 'l') + cdesc[column].hdrtok->adjustment = Left; + else if(*p == 'R' || *p == 'r') + cdesc[column].hdrtok->adjustment = Right; + else{ + dprint((1, "parse_index_token: HEADER 4th argument should be L or R, not\n", *p ? p : "<null>")); + q_status_message(SM_ORDER | SM_DING, 0, 3, "HEADER 4th argument should be L or R"); + } + } + } + } + else{ + dprint((1, "parse_index_token: HEADER 2nd argument should be field number, not\n", *p ? p : "<null>")); + q_status_message(SM_ORDER | SM_DING, 0, 3, "HEADER 2nd argument should be field number, a non-negative digit"); + } + } + } + else{ + if(p && *p && *p == ')' && p > q){ + cdesc[column].wtype = Fixed; + cdesc[column].req_width = atoi(q); + } + else if(p && *p && *p == '%' && p > q){ + cdesc[column].wtype = Percent; + cdesc[column].req_width = atoi(q); + } + else{ + cdesc[column].wtype = WeCalculate; + cdesc[column].req_width = 0; + } + } + } + else{ + /* if they left out width for iText we can figure it out */ + if(pt->ctype == iText && cdesc[column].hdrtok && cdesc[column].hdrtok->hdrname){ + cdesc[column].wtype = Fixed; + cdesc[column].req_width = utf8_width(cdesc[column].hdrtok->hdrname); + } + else{ + cdesc[column].wtype = WeCalculate; + cdesc[column].req_width = 0; + } + } + + column++; + /* skip text at end of word */ + while(p && *p && !isspace((unsigned char)*p)) + p++; + } + + /* if, after all that, we didn't find anything recognizable, bitch */ + if(!column){ + dprint((1, "Completely unrecognizable index-format\n")); + q_status_message(SM_ORDER | SM_DING, 0, 3, + _("Configured \"index-format\" unrecognizable. Using default.")); + return(0); + } + + /* Finish with Nothing column */ + cdesc[column].ctype = iNothing; + + /* free up old answer */ + if(*answer) + free_index_format(answer); + + /* allocate space for new answer */ + *answer = (INDEX_COL_S *)fs_get((column+1)*sizeof(INDEX_COL_S)); + memset((void *)(*answer), 0, (column+1)*sizeof(INDEX_COL_S)); + /* copy answer to real place */ + for(i = 0; i <= column; i++) + (*answer)[i] = cdesc[i]; + + return(1); +} + + +/* + * These types are basically fixed in width. + * The order is slightly significant. The ones towards the front of the + * list get space allocated sooner than the ones at the end of the list. + */ +static IndexColType fixed_ctypes[] = { + iMessNo, iStatus, iFStatus, iIStatus, iSIStatus, + iDate, iSDate, iSDateTime, iSDateTime24, + iSTime, iLDate, + iS1Date, iS2Date, iS3Date, iS4Date, iDateIso, iDateIsoS, + iSDateIso, iSDateIsoS, + iSDateS1, iSDateS2, iSDateS3, iSDateS4, + iSDateTimeIso, iSDateTimeIsoS, + iSDateTimeS1, iSDateTimeS2, iSDateTimeS3, iSDateTimeS4, + iSDateTimeIso24, iSDateTimeIsoS24, + iSDateTimeS124, iSDateTimeS224, iSDateTimeS324, iSDateTimeS424, + iSize, iSizeComma, iSizeNarrow, iKSize, iDescripSize, + iPrio, iPrioBang, iPrioAlpha, iInit, + iAtt, iTime24, iTime12, iTimezone, iMonAbb, iYear, iYear2Digit, + iDay2Digit, iMon2Digit, iDayOfWeekAbb, iScore, iMonLong, iDayOfWeek +}; + + +int +ctype_is_fixed_length(IndexColType ctype) +{ + int j; + + for(j = 0; ; j++){ + if(j >= sizeof(fixed_ctypes)/sizeof(*fixed_ctypes)) + break; + + if(ctype == fixed_ctypes[j]) + return 1; + } + + return 0; +} + + +/*---------------------------------------------------------------------- + Setup the widths of the various columns in the index display + ----*/ +void +setup_index_header_widths(MAILSTREAM *stream) +{ + int colspace; /* for reserving space between columns */ + int j, some_to_calculate; + int space_left, screen_width, fix; + int keep_going, tot_pct, was_sl; + long max_msgno; + WidthType wtype; + INDEX_COL_S *cdesc; + + max_msgno = mn_get_total(ps_global->msgmap); + + dprint((8, "=== setup_index_header_widths() ===\n")); + + clear_icache_flags(stream); + screen_width = ps_global->ttyo->screen_cols; + space_left = screen_width; + some_to_calculate = 0; + colspace = -1; + + /* + * Calculate how many fields there are so we know how many spaces + * between columns to reserve. Fill in Fixed widths now. Reserve + * special case WeCalculate with non-zero req_widths before doing + * Percent cases below. + */ + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing; + cdesc++){ + + if(cdesc->wtype == Fixed){ + cdesc->width = cdesc->req_width; + if(cdesc->width > 0) + colspace++; + } + else if(cdesc->wtype == Percent){ + cdesc->width = 0; /* calculated later */ + colspace++; + } + else{ /* WeCalculate */ + cdesc->width = cdesc->req_width; /* reserve this for now */ + some_to_calculate++; + colspace++; + } + + /* no space after iText */ + if(cdesc->ctype == iText) + colspace--; + + space_left -= cdesc->width; + } + + colspace = MAX(colspace, 0); + + space_left -= colspace; /* space between columns */ + + ps_global->display_keywords_in_subject = 0; + ps_global->display_keywordinits_in_subject = 0; + + /* + * Set the actual lengths for the fixed width fields and set up + * the left or right adjustment for everything. + * There should be a case setting actual_length for all of the types + * in fixed_ctypes. + */ + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing; + cdesc++){ + + wtype = cdesc->wtype; + + if(cdesc->ctype == iSubjKey || cdesc->ctype == iSubjKeyText) + ps_global->display_keywords_in_subject = 1; + else if(cdesc->ctype == iSubjKeyInit || cdesc->ctype == iSubjKeyInitText) + ps_global->display_keywordinits_in_subject = 1; + + if(wtype == WeCalculate || wtype == Percent || cdesc->width != 0){ + + switch(cdesc->ctype){ + case iSDate: case iSDateIso: case iSDateIsoS: + case iSDateS1: case iSDateS2: case iSDateS3: case iSDateS4: + case iSDateTime: case iSDateTimeIso: case iSDateTimeIsoS: + case iSDateTimeS1: case iSDateTimeS2: case iSDateTimeS3: case iSDateTimeS4: + case iSDateTime24: case iSDateTimeIso24: case iSDateTimeIsoS24: + case iSDateTimeS124: case iSDateTimeS224: case iSDateTimeS324: case iSDateTimeS424: + case iSTime: + set_format_includes_smartdate(stream); + break; + + default: + break; + } + + if(ctype_is_fixed_length(cdesc->ctype)){ + switch(cdesc->ctype){ + case iPrio: + case iPrioBang: + case iAtt: + cdesc->actual_length = 1; + cdesc->adjustment = Left; + break; + + case iYear2Digit: + case iDay2Digit: + case iMon2Digit: + cdesc->actual_length = 2; + cdesc->adjustment = Left; + break; + + case iArrow: + cdesc->actual_length = 2; + cdesc->adjustment = Right; + break; + + case iStatus: + case iInit: + cdesc->actual_length = 3; + cdesc->adjustment = Left; + break; + + case iMessNo: + set_format_includes_msgno(stream); + if(max_msgno < 1000) + cdesc->actual_length = 3; + else if(max_msgno < 10000) + cdesc->actual_length = 4; + else if(max_msgno < 100000) + cdesc->actual_length = 5; + else + cdesc->actual_length = 6; + + cdesc->adjustment = Right; + break; + + case iYear: + case iSIStatus: + cdesc->actual_length = 4; + cdesc->adjustment = Left; + break; + + case iTime24: + case iTimezone: + cdesc->actual_length = 5; + cdesc->adjustment = Left; + break; + + case iSizeNarrow: + cdesc->actual_length = 5; + cdesc->adjustment = Right; + break; + + case iFStatus: + case iIStatus: + cdesc->actual_length = 6; + cdesc->adjustment = Left; + break; + + case iScore: + cdesc->actual_length = 6; + cdesc->adjustment = Right; + break; + + case iTime12: + case iSize: + case iKSize: + cdesc->actual_length = 7; + cdesc->adjustment = Right; + break; + + case iSTime: + cdesc->actual_length = 7; + cdesc->adjustment = Left; + break; + + case iPrioAlpha: + cdesc->actual_length = 7; + cdesc->adjustment = Left; + break; + + + case iS1Date: + case iS2Date: + case iS3Date: + case iS4Date: + case iDateIsoS: + cdesc->actual_length = 8; + cdesc->adjustment = Left; + break; + + case iSizeComma: + cdesc->actual_length = 8; + cdesc->adjustment = Right; + break; + + case iSDate: + case iSDateTime: + case iSDateTime24: + case iMonAbb: + case iDayOfWeekAbb: + case iDayOfWeek: + case iDate: + case iMonLong: + cdesc->actual_length = cdesc->req_width; + cdesc->adjustment = Left; + break; + + case iSDateIsoS: + case iSDateS1: case iSDateS2: case iSDateS3: case iSDateS4: + case iSDateTimeIsoS: + case iSDateTimeIsoS24: + case iSDateTimeS1: case iSDateTimeS2: case iSDateTimeS3: case iSDateTimeS4: + case iSDateTimeS124: case iSDateTimeS224: case iSDateTimeS324: case iSDateTimeS424: + case iSDateIso: case iSDateTimeIso: case iSDateTimeIso24: + if(cdesc->ctype == iSDateIso + || cdesc->ctype == iSDateTimeIso + || cdesc->ctype == iSDateTimeIso24) + cdesc->actual_length = 10; + else + cdesc->actual_length = 9; + + cdesc->adjustment = Left; + break; + + case iDescripSize: + cdesc->actual_length = 9; + cdesc->adjustment = Right; + break; + + case iDateIso: + cdesc->actual_length = 10; + cdesc->adjustment = Left; + break; + + case iLDate: + cdesc->actual_length = 12; + cdesc->adjustment = Left; + break; + + default: + panic("Unhandled fixed case in setup_index_header"); + break; + } + } + else if(cdesc->ctype == iHeader) + cdesc->adjustment = cdesc->hdrtok ? cdesc->hdrtok->adjustment : Left; + else + cdesc->adjustment = Left; + } + } + + if(ps_global->display_keywords_in_subject) + ps_global->display_keywordinits_in_subject = 0; + + /* if have reserved unneeded space for size, give it back */ + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing; + cdesc++) + if(cdesc->ctype == iSize || cdesc->ctype == iKSize || + cdesc->ctype == iSizeNarrow || + cdesc->ctype == iSizeComma || cdesc->ctype == iDescripSize){ + if(cdesc->actual_length == 0){ + if((fix=cdesc->width) > 0){ /* had this reserved */ + cdesc->width = 0; + space_left += fix; + } + + space_left++; /* +1 for space between columns */ + } + } + + /* + * Calculate the field widths that are basically fixed in width. + * Do them in this order in case we don't have enough space to go around. + * The set of fixed_ctypes here is the same as the set where we + * set the actual_lengths above. + */ + for(j = 0; space_left > 0 && some_to_calculate; j++){ + + if(j >= sizeof(fixed_ctypes)/sizeof(*fixed_ctypes)) + break; + + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing && space_left > 0 && some_to_calculate; + cdesc++) + if(cdesc->ctype == fixed_ctypes[j] && cdesc->wtype == WeCalculate){ + some_to_calculate--; + fix = MIN(cdesc->actual_length - cdesc->width, space_left); + cdesc->width += fix; + space_left -= fix; + } + } + + /* + * Fill in widths for Percent cases. If there are no more to calculate, + * use the percentages as relative numbers and use the rest of the space, + * else treat them as absolute percentages of the original avail screen. + */ + if(space_left > 0){ + if(some_to_calculate){ + int tot_requested = 0; + + /* + * Requests are treated as percent of screen width. See if they + * will all fit. If not, trim them back proportionately. + */ + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing; + cdesc++){ + if(cdesc->wtype == Percent){ + /* The 2, 200, and +100 are because we're rounding */ + fix = ((2*cdesc->req_width * + (screen_width-colspace))+100) / 200; + tot_requested += fix; + } + } + + if(tot_requested > space_left){ + int multiplier = (100 * space_left) / tot_requested; + + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing && space_left > 0; + cdesc++){ + if(cdesc->wtype == Percent){ + /* The 2, 200, and +100 are because we're rounding */ + fix = ((2*cdesc->req_width * + (screen_width-colspace))+100) / 200; + fix = (2 * fix * multiplier + 100) / 200; + fix = MIN(fix, space_left); + cdesc->width += fix; + space_left -= fix; + } + } + } + else{ + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing && space_left > 0; + cdesc++){ + if(cdesc->wtype == Percent){ + /* The 2, 200, and +100 are because we're rounding */ + fix = ((2*cdesc->req_width * + (screen_width-colspace))+100) / 200; + fix = MIN(fix, space_left); + cdesc->width += fix; + space_left -= fix; + } + } + } + } + else{ + tot_pct = 0; + was_sl = space_left; + /* add up total percentages requested */ + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing; + cdesc++) + if(cdesc->wtype == Percent) + tot_pct += cdesc->req_width; + + /* give relative weight to requests */ + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing && space_left > 0 && tot_pct > 0; + cdesc++){ + if(cdesc->wtype == Percent){ + fix = ((2*cdesc->req_width*was_sl)+tot_pct) / (2*tot_pct); + fix = MIN(fix, space_left); + cdesc->width += fix; + space_left -= fix; + } + } + } + } + + /* split up rest, give twice as much to Subject */ + keep_going = 1; + while(space_left > 0 && keep_going){ + keep_going = 0; + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing && space_left > 0; + cdesc++){ + if(cdesc->wtype == WeCalculate && !ctype_is_fixed_length(cdesc->ctype)){ + keep_going++; + cdesc->width++; + space_left--; + if(space_left > 0 && (cdesc->ctype == iSubject + || cdesc->ctype == iSubjectText + || cdesc->ctype == iSubjKey + || cdesc->ctype == iSubjKeyText + || cdesc->ctype == iSubjKeyInit + || cdesc->ctype == iSubjKeyInitText)){ + cdesc->width++; + space_left--; + } + } + } + } + + /* if still more, pad out percent's */ + keep_going = 1; + while(space_left > 0 && keep_going){ + keep_going = 0; + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing && space_left > 0; + cdesc++){ + if(cdesc->wtype == Percent && !ctype_is_fixed_length(cdesc->ctype)){ + keep_going++; + cdesc->width++; + space_left--; + } + } + } + + /* if user made Fixed fields too big, give back space */ + keep_going = 1; + while(space_left < 0 && keep_going){ + keep_going = 0; + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing && space_left < 0; + cdesc++){ + if(cdesc->wtype == Fixed && cdesc->width > 0){ + keep_going++; + cdesc->width--; + space_left++; + } + } + } + + if(pith_opt_save_index_state) + (*pith_opt_save_index_state)(FALSE); +} + + +void +setup_thread_header_widths(MAILSTREAM *stream) +{ + clear_icache_flags(stream); + if(pith_opt_save_index_state) + (*pith_opt_save_index_state)(TRUE); +} + + +/* + * load_overview - c-client call back to gather overview data + * + * Note: if we never get called, UID represents a hole + * if we're passed a zero UID, totally bogus overview data + * if we're passed a zero obuf, mostly bogus overview data + */ +void +load_overview(MAILSTREAM *stream, imapuid_t uid, OVERVIEW *obuf, long unsigned int rawno) +{ + if(obuf && rawno >= 1L && stream && rawno <= stream->nmsgs){ + INDEXDATA_S idata; + ICE_S *ice; + + memset(&idata, 0, sizeof(INDEXDATA_S)); + idata.no_fetch = 1; + + /* + * Only really load the thing if we've got an NNTP stream + * otherwise we're just using mail_fetch_overview to load the + * IMAP envelope cache with the specific set of messages + * in a single RTT. + */ + idata.stream = stream; + idata.rawno = rawno; + idata.msgno = mn_raw2m(sp_msgmap(stream), idata.rawno); + idata.size = obuf->optional.octets; + idata.from = obuf->from; + idata.date = obuf->date; + idata.subject = obuf->subject; + + ice = (*format_index_line)(&idata); + if(idata.bogus && ice){ + if(THRD_INDX()){ + if(ice->tice) + clear_ice(&ice->tice); + } + else + clear_ice(&ice); + } + else if(F_OFF(F_QUELL_NEWS_ENV_CB, ps_global) + && (!THRD_INDX() || (ice && ice->tice)) + && !msgline_hidden(stream, sp_msgmap(stream), idata.msgno, 0) + && pith_opt_paint_index_hline){ + (*pith_opt_paint_index_hline)(stream, idata.msgno, ice); + } + } +} + + +ICE_S * +build_header_work(struct pine *state, MAILSTREAM *stream, MSGNO_S *msgmap, + long int msgno, long int top_msgno, int msgcount, int *fetched) +{ + ICE_S *ice, *ic; + MESSAGECACHE *mc; + long n, i, cnt, rawno, visible, limit = -1L; + + rawno = mn_m2raw(msgmap, msgno); + + /* cache hit? */ + if(THRD_INDX()){ + ice = fetch_ice(stream, rawno); + if(!ice) + return(NULL); + + if(ice->tice && ice->tice->ifield + && ice->tice->color_lookup_done && ice->tice->widths_done){ +#ifdef DEBUG + char buf[MAX_SCREEN_COLS+1]; + simple_index_line(buf, sizeof(buf), ice->tice, msgno); +#endif + dprint((9, "Hitt: Returning %p -> <%s (%d)\n", + ice->tice, + buf[0] ? buf : "?", + buf[0] ? strlen(buf) : 0)); + return(ice); + } + } + else{ + ice = fetch_ice(stream, rawno); + if(!ice) + return(NULL); + + if(ice->ifield && ice->color_lookup_done && ice->widths_done){ +#ifdef DEBUG + char buf[MAX_SCREEN_COLS+1]; + simple_index_line(buf, sizeof(buf), ice, msgno); +#endif + dprint((9, "Hit: Returning %p -> <%s (%d)\n", + ice, + buf[0] ? buf : "?", + buf[0] ? strlen(buf) : 0)); + return(ice); + } + } + + /* + * If we are in THRD_INDX() and the width changed we don't currently + * have a method of fixing just the widths and print_format strings. + * Instead, we clear the index cache entry and start over. + */ + if(THRD_INDX() && ice && ice->tice && ice->tice->ifield + && !ice->tice->widths_done){ + clear_ice(&ice->tice); + } + + /* + * Fetch everything we need to start filling in the index line + * explicitly via mail_fetch_overview. On an nntp stream + * this has the effect of building the index lines in the + * load_overview callback. Under IMAP we're either getting + * the envelope data via the imap_envelope callback or + * preloading the cache. Either way, we're getting exactly + * what we want rather than relying on linear lookahead sort + * of prefetch... + */ + if(!(fetched && *fetched) && index_in_overview(stream) + && ((THRD_INDX() && !(ice->tice && ice->tice->ifield)) + || (!THRD_INDX() && !ice->ifield))){ + char *seq; + int count; + MESSAGECACHE *mc; + PINETHRD_S *thrd; + + if(fetched) + (*fetched)++; + + /* clear sequence bits */ + for(n = 1L; n <= stream->nmsgs; n++) + if((mc = mail_elt(stream, n)) != NULL) + mc->sequence = 0; + + /* + * Light interesting bits + * NOTE: not set above because m2raw's cheaper + * than raw2m for every message + */ + + /* + * Unfortunately, it is expensive to calculate visible pages + * in thread index if we are zoomed, so we don't try. + */ + if(THRD_INDX() && any_lflagged(msgmap, MN_HIDE)) + visible = msgmap->visible_threads; + else if(THREADING() && sp_viewing_a_thread(stream)){ + /* + * We know that all visible messages in the thread are marked + * with MN_CHID2. + */ + for(visible = 0L, n = top_msgno; + visible < msgcount && n <= mn_get_total(msgmap); + n++){ + + if(!get_lflag(stream, msgmap, n, MN_CHID2)) + break; + + if(!msgline_hidden(stream, msgmap, n, 0)) + visible++; + } + + } + else + visible = mn_get_total(msgmap) + - any_lflagged(msgmap, MN_HIDE|MN_CHID); + + limit = MIN(visible, msgcount); + + if(THRD_INDX()){ + count = i = 0; + + /* + * First add the msgno we're asking for in case it + * isn't visible. + */ + thrd = fetch_thread(stream, mn_m2raw(msgmap, msgno)); + if(msgno <= mn_get_total(msgmap) + && (!(ic=fetch_ice(stream,thrd->rawno)) || !(ic=ic->tice) || !ic->ifield)){ + count += mark_msgs_in_thread(stream, thrd, msgmap); + } + + thrd = fetch_thread(stream, mn_m2raw(msgmap, top_msgno)); + + /* + * Loop through visible threads, marking them for fetching. + * Stop at end of screen or sooner if we run out of visible + * threads. + */ + while(thrd){ + n = mn_raw2m(msgmap, thrd->rawno); + if(n >= msgno + && n <= mn_get_total(msgmap) + && (!(ic=fetch_ice(stream,thrd->rawno)) || !(ic=ic->tice) || !ic->ifield)){ + count += mark_msgs_in_thread(stream, thrd, msgmap); + } + + if(++i >= limit) + break; + + /* find next thread which is visible */ + do{ + if(mn_get_revsort(msgmap) && thrd->prevthd) + thrd = fetch_thread(stream, thrd->prevthd); + else if(!mn_get_revsort(msgmap) && thrd->nextthd) + thrd = fetch_thread(stream, thrd->nextthd); + else + thrd = NULL; + } while(thrd + && msgline_hidden(stream, msgmap, + mn_raw2m(msgmap, thrd->rawno), 0)); + } + } + else{ + count = i = 0; + + /* + * First add the msgno we're asking for in case it + * isn't visible. + */ + if(msgno > 0L && msgno <= mn_get_total(msgmap) + && (!(ic=fetch_ice(stream, (rawno=mn_m2raw(msgmap,msgno)))) || !ic->ifield)){ + if((thrd = fetch_thread(stream, rawno)) != NULL){ + /* + * If we're doing a MUTTLIKE display the index line + * may depend on the thread parent, and grandparent, + * and further back. So just fetch the whole thread + * in that case. + */ + if(THREADING() + && ps_global->thread_disp_style == THREAD_MUTTLIKE + && thrd->top) + thrd = fetch_thread(stream, thrd->top); + + count += mark_msgs_in_thread(stream, thrd, msgmap); + } + else if(rawno > 0L && rawno <= stream->nmsgs + && (mc = mail_elt(stream,rawno)) + && !mc->private.msg.env){ + mc->sequence = 1; + count++; + } + } + + n = top_msgno; + while(1){ + if(n >= msgno + && n <= mn_get_total(msgmap) + && (!(ic=fetch_ice(stream, (rawno=mn_m2raw(msgmap,n)))) || !ic->ifield)){ + if((thrd = fetch_thread(stream, rawno)) != NULL){ + /* + * If we're doing a MUTTLIKE display the index line + * may depend on the thread parent, and grandparent, + * and further back. So just fetch the whole thread + * in that case. + */ + if(THREADING() + && ps_global->thread_disp_style == THREAD_MUTTLIKE + && thrd->top) + thrd = fetch_thread(stream, thrd->top); + + count += mark_msgs_in_thread(stream, thrd, msgmap); + } + else if(rawno > 0L && rawno <= stream->nmsgs + && (mc = mail_elt(stream,rawno)) + && !mc->private.msg.env){ + mc->sequence = 1; + count++; + } + } + + if(++i >= limit) + break; + + /* find next n which is visible */ + while(++n <= mn_get_total(msgmap) + && msgline_hidden(stream, msgmap, n, 0)) + ; + } + } + + if(count){ + seq = build_sequence(stream, NULL, NULL); + if(seq){ + ps_global->dont_count_flagchanges = 1; + mail_fetch_overview_sequence(stream, seq, + (stream->dtb && stream->dtb->name + && !strcmp(stream->dtb->name, "imap")) + ? NULL : load_overview); + ps_global->dont_count_flagchanges = 0; + fs_give((void **) &seq); + } + } + + /* + * reassign ice from the cache as it may've been built + * within the overview callback or it may have become stale + * in the prior sequence bit setting loop ... + */ + rawno = mn_m2raw(msgmap, msgno); + ice = fetch_ice(stream, rawno); + if(!ice) + return(NULL); + } + + if((THRD_INDX() && !(ice->tice && ice->tice->ifield)) + || (!THRD_INDX() && !ice->ifield)){ + INDEXDATA_S idata; + + /* + * With pre-fetching/callback-formatting done and no success, + * fall into formatting the requested line... + */ + memset(&idata, 0, sizeof(INDEXDATA_S)); + idata.stream = stream; + idata.msgno = msgno; + idata.rawno = mn_m2raw(msgmap, msgno); + if(stream && idata.rawno > 0L && idata.rawno <= stream->nmsgs + && (mc = mail_elt(stream, idata.rawno))){ + idata.size = mc->rfc822_size; + index_data_env(&idata, pine_mail_fetchenvelope(stream,idata.rawno)); + } + else + idata.bogus = 2; + + ice = (*format_index_line)(&idata); + if(!ice) + return(NULL); + } + + /* + * If needed, reset the print_format strings so that they add up to + * the right total width. The reset width functionality isn't implemented + * for THRD_INDX() so we are just doing a complete rebuild in that + * case. This is driven by the clear_ice() call in clear_index_cache_ent() + * so it should never be the case that THRD_INDX() is true and only + * widths_done needs to be fixed. + */ + if((!THRD_INDX() && ice->ifield && !ice->widths_done)){ + ICE_S *working_ice; + IFIELD_S *ifield; + INDEX_COL_S *cdesc; + + if(need_format_setup(stream)) + setup_header_widths(stream); + + if(THRD_INDX()) + working_ice = ice ? ice->tice : NULL; + else + working_ice = ice; + + if(working_ice){ + /* + * First fix the ifield widths. The cdescs with nonzero widths + * should correspond to the ifields that are defined. + */ + ifield = working_ice->ifield; + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing && ifield; cdesc++){ + if(cdesc->width){ + if(cdesc->ctype != ifield->ctype){ + dprint((1, "build_header_work(%ld): cdesc->ctype=%d != ifield->ctype=%d NOT SUPPOSED TO HAPPEN!\n", msgno, (int) cdesc->ctype, (int) ifield->ctype)); + assert(0); + } + + ifield->width = cdesc->width; + ifield = ifield->next; + } + } + + /* fix the print_format strings and widths */ + for(ifield = working_ice->ifield; ifield; ifield = ifield->next) + set_ielem_widths_in_field(ifield); + + working_ice->widths_done = 1; + } + } + + if(THRD_INDX() && ice->tice) + ice->tice->color_lookup_done = 1; + + /* + * Look for a color for this line (and other lines in the current + * view). This does a SEARCH for each role which has a color until + * it finds a match. This will be satisfied by the c-client + * cache created by the mail_fetch_overview above if it is a header + * search. + */ + if(!THRD_INDX() && !ice->color_lookup_done){ + COLOR_PAIR *linecolor; + SEARCHSET *ss, *s; + ICE_S *ic; + PAT_STATE *pstate = NULL; + + if(pico_usingcolor()){ + if(limit < 0L){ + if(THREADING() && sp_viewing_a_thread(stream)){ + for(visible = 0L, n = top_msgno; + visible < msgcount && n <= mn_get_total(msgmap); + n++){ + + if(!get_lflag(stream, msgmap, n, MN_CHID2)) + break; + + if(!msgline_hidden(stream, msgmap, n, 0)) + visible++; + } + + } + else + visible = mn_get_total(msgmap) + - any_lflagged(msgmap, MN_HIDE|MN_CHID); + + limit = MIN(visible, msgcount); + } + /* clear sequence bits */ + for(n = 1L; n <= stream->nmsgs; n++) + if((mc = mail_elt(stream, n)) != NULL) + mc->sequence = 0; + + cnt = i = 0; + n = top_msgno; + while(1){ + if(n >= msgno + && n <= mn_get_total(msgmap) + && (!(ic=fetch_ice(stream,(rawno = mn_m2raw(msgmap, n)))) || !ic->color_lookup_done)){ + + if(rawno >= 1L && rawno <= stream->nmsgs + && (mc = mail_elt(stream, rawno))){ + mc->sequence = 1; + cnt++; + } + } + + if(++i >= limit) + break; + + /* find next n which is visible */ + while(++n <= mn_get_total(msgmap) + && msgline_hidden(stream, msgmap, n, 0)) + ; + } + + /* + * Why is there a loop here? The first call to get_index_line_color + * will return a set of messages which match one of the roles. + * Then, we eliminate those messages from the search set and try + * again. This time we'd get past that role and into a different + * role. Because of that, we hang onto the state and don't reset + * to the first_pattern on the second and subsequent times + * through the loop, avoiding fruitless match_pattern calls in + * get_index_line_color. + * Before the first call, pstate should be set to NULL. + */ + while(cnt > 0L){ + ss = build_searchset(stream); + if(ss){ + int colormatch; + + linecolor = NULL; + colormatch = get_index_line_color(stream, ss, &pstate, + &linecolor); + + /* + * Assign this color to all matched msgno's and + * turn off the sequence bit so we won't check + * for them again. + */ + if(colormatch){ + for(s = ss; s; s = s->next){ + for(n = s->first; n <= s->last; n++){ + if(n >= 1L && n <= stream->nmsgs + && (mc = mail_elt(stream, n)) + && mc->searched){ + cnt--; + mc->sequence = 0; + ic = fetch_ice(stream, n); + if(ic){ + ic->color_lookup_done = 1; + if(linecolor) + ic->linecolor = new_color_pair(linecolor->fg, + linecolor->bg); + } + } + } + } + + if(linecolor) + free_color_pair(&linecolor); + } + else{ + /* have to mark the rest of the lookups done */ + for(s = ss; s && cnt > 0; s = s->next){ + for(n = s->first; n <= s->last && cnt > 0; n++){ + if(n >= 1L && n <= stream->nmsgs + && (mc = mail_elt(stream, n)) + && mc->sequence){ + cnt--; + ic = fetch_ice(stream, n); + if(ic) + ic->color_lookup_done = 1; + } + } + } + + /* just making sure */ + cnt = 0L; + } + + mail_free_searchset(&ss); + } + else + cnt = 0L; + } + + ice = fetch_ice(stream, mn_m2raw(msgmap, msgno)); + } + else + ice->color_lookup_done = 1; + } + + return(ice); /* Return formatted index data */ +} + + +int +day_of_week(struct date *d) +{ + int m, y; + + m = d->month; + y = d->year; + if(m <= 2){ + m += 9; + y--; + } + else + m -= 3; /* March is month 0 */ + + return((d->day+2+((7+31*m)/12)+y+(y/4)+(y/400)-(y/100))%7); +} + + +static int daytab[2][13] = { + {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, + {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} +}; + +int +day_of_year(struct date *d) +{ + int i, leap, doy; + + if(d->year <= 0 || d->month < 1 || d->month > 12) + return(-1); + + doy = d->day; + leap = (d->year%4 == 0 && d->year%100 != 0) || d->year%400 == 0; + for(i = 1; i < d->month; i++) + doy += daytab[leap][i]; + + return(doy); +} + + + +/*---------------------------------------------------------------------- + Format a string summarizing the message header for index on screen + + Args: buffer -- buffer to place formatted line + idata -- snot it takes to format the line + + Result: returns pointer given buffer IF entry formatted + else NULL if there was a problem (but the buffer is + still suitable for display) + ----*/ +ICE_S * +format_index_index_line(INDEXDATA_S *idata) +{ + char str[BIGWIDTH+1], to_us, status, *field, + *p, *newsgroups; + int i, collapsed = 0, start, fromfield; + long l, score; + BODY *body = NULL; + MESSAGECACHE *mc; + ADDRESS *addr, *toaddr, *ccaddr, *last_to; + PINETHRD_S *thrd = NULL; + INDEX_COL_S *cdesc = NULL; + ICE_S *ice, **icep; + IFIELD_S *ifield; + IELEM_S *ielem; + struct variable *vars = ps_global->vars; + + dprint((8, "=== format_index_line(msgno=%ld,rawno=%ld) ===\n", + idata ? idata->msgno : -1, idata ? idata->rawno : -1)); + + + ice = fetch_ice(idata->stream, idata->rawno); + if(!ice) + return(NULL); + + free_ifield(&ice->ifield); + + /* + * Operate on a temporary copy of ice. The reason for this + * is that we may end up causing a pine_mail_fetchenvelope() call + * (e.g., in to_us_symbol_for_thread()) that causes an mm_flags() + * and mm_flags may do a clear_ice(), freeing the ice we are working + * on out from under us. We try to fetch everything we need in + * build_header_work() but c-client will short-circuit our request + * if we already got the raw header for some reason. One possible + * reason is a categorizer command in a filter. In that case + * we still need a fetch fast to get the rest of the envelope data. + */ + ice = copy_ice(ice); + + /* is this a collapsed thread index line? */ + if(!idata->bogus && THREADING()){ + thrd = fetch_thread(idata->stream, idata->rawno); + collapsed = thrd && thrd->next + && get_lflag(idata->stream, NULL, + idata->rawno, MN_COLL); + } + + /* calculate contents of the required fields */ + for(cdesc = ps_global->index_disp_format; cdesc->ctype != iNothing; cdesc++) + if(cdesc->width){ + memset(str, 0, sizeof(str)); + ifield = new_ifield(&ice->ifield); + ifield->ctype = cdesc->ctype; + ifield->width = cdesc->width; + fromfield = 0; + + if(idata->bogus){ + if(cdesc->ctype == iMessNo) + snprintf(str, sizeof(str), "%*.*s", ifield->width, ifield->width, " "); + else if(idata->bogus < 2 && (cdesc->ctype == iSubject + || cdesc->ctype == iSubjectText + || cdesc->ctype == iSubjKey + || cdesc->ctype == iSubjKeyText + || cdesc->ctype == iSubjKeyInit + || cdesc->ctype == iSubjKeyInitText)) + snprintf(str, sizeof(str), "%s", _("[ No Message Text Available ]")); + } + else + switch(cdesc->ctype){ + case iStatus: + to_us = status = ' '; + if(collapsed){ + thrd = fetch_thread(idata->stream, idata->rawno); + to_us = to_us_symbol_for_thread(idata->stream, thrd, 1); + status = status_symbol_for_thread(idata->stream, thrd, + cdesc->ctype); + } + else{ + if((mc=mail_elt(idata->stream,idata->rawno)) && mc->flagged) + to_us = '*'; /* simple */ + else if(!IS_NEWS(idata->stream)){ + for(addr = fetch_to(idata); addr; addr = addr->next) + if(address_is_us(addr, ps_global)){ + ice->to_us = 1; + if(to_us == ' ') + to_us = '+'; + + break; + } + + if(to_us != '+' && resent_to_us(idata)){ + ice->to_us = 1; + if(to_us == ' ') + to_us = '+'; + } + + if(to_us == ' ' && F_ON(F_MARK_FOR_CC,ps_global)) + for(addr = fetch_cc(idata); addr; addr = addr->next) + if(address_is_us(addr, ps_global)){ + ice->cc_us = 1; + to_us = '-'; + break; + } + } + + status = (!idata->stream || !IS_NEWS(idata->stream) + || F_ON(F_FAKE_NEW_IN_NEWS, ps_global)) + ? 'N' : ' '; + + if(mc->seen) + status = ' '; + + if(user_flag_is_set(idata->stream, idata->rawno, FORWARDED_FLAG)) + status = 'F'; + + if(mc->answered) + status = 'A'; + + if(mc->deleted) + status = 'D'; + } + + snprintf(str, sizeof(str), "%c %c", to_us, status); + + ifield->leftadj = 1; + for(i = 0; i < 3; i++){ + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->data = (char *) fs_get(2 * sizeof(char)); + ielem->data[0] = str[i]; + ielem->data[1] = '\0'; + ielem->datalen = 1; + set_print_format(ielem, 1, ifield->leftadj); + } + + if(pico_usingcolor()){ + + if(str[0] == '*'){ + if(VAR_IND_IMP_FORE_COLOR && VAR_IND_IMP_BACK_COLOR){ + ielem = ifield->ielem; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_IMP_FORE_COLOR, VAR_IND_IMP_BACK_COLOR); + } + } + else if(str[0] == '+' || str[0] == '-'){ + if(VAR_IND_PLUS_FORE_COLOR && VAR_IND_PLUS_BACK_COLOR){ + ielem = ifield->ielem; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_PLUS_FORE_COLOR, VAR_IND_PLUS_BACK_COLOR); + } + } + + if(str[2] == 'D'){ + if(VAR_IND_DEL_FORE_COLOR && VAR_IND_DEL_BACK_COLOR){ + ielem = ifield->ielem->next->next; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_DEL_FORE_COLOR, VAR_IND_DEL_BACK_COLOR); + } + } + else if(str[2] == 'A'){ + if(VAR_IND_ANS_FORE_COLOR && VAR_IND_ANS_BACK_COLOR){ + ielem = ifield->ielem->next->next; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_ANS_FORE_COLOR, VAR_IND_ANS_BACK_COLOR); + } + } + else if(str[2] == 'F'){ + if(VAR_IND_FWD_FORE_COLOR && VAR_IND_FWD_BACK_COLOR){ + ielem = ifield->ielem->next->next; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_FWD_FORE_COLOR, VAR_IND_FWD_BACK_COLOR); + } + } + else if(str[2] == 'N'){ + if(VAR_IND_NEW_FORE_COLOR && VAR_IND_NEW_BACK_COLOR){ + ielem = ifield->ielem->next->next; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_NEW_FORE_COLOR, VAR_IND_NEW_BACK_COLOR); + } + } + } + + break; + + case iFStatus: + case iIStatus: + case iSIStatus: + { + char new, answered, deleted, flagged; + + if(collapsed){ + thrd = fetch_thread(idata->stream, idata->rawno); + to_us = to_us_symbol_for_thread(idata->stream, thrd, 0); + } + else{ + to_us = ' '; + if(!IS_NEWS(idata->stream)){ + for(addr = fetch_to(idata); addr; addr = addr->next) + if(address_is_us(addr, ps_global)){ + to_us = '+'; + break; + } + + if(to_us == ' ' && resent_to_us(idata)) + to_us = '+'; + + if(to_us == ' ' && F_ON(F_MARK_FOR_CC,ps_global)) + for(addr = fetch_cc(idata); addr; addr = addr->next) + if(address_is_us(addr, ps_global)){ + to_us = '-'; + break; + } + } + } + + new = answered = deleted = flagged = ' '; + + if(collapsed){ + unsigned long save_branch, cnt, tot_in_thrd; + + /* + * Branch is a sibling, not part of the thread, so + * don't consider it when displaying this line. + */ + save_branch = thrd->branch; + thrd->branch = 0L; + + tot_in_thrd = count_flags_in_thread(idata->stream, thrd, + F_NONE); + + cnt = count_flags_in_thread(idata->stream, thrd, F_DEL); + if(cnt) + deleted = (cnt == tot_in_thrd) ? 'D' : 'd'; + + cnt = count_flags_in_thread(idata->stream, thrd, F_ANS); + if(cnt) + answered = (cnt == tot_in_thrd) ? 'A' : 'a'; + + /* no lower case *, same thing for some or all */ + if(count_flags_in_thread(idata->stream, thrd, F_FLAG)) + flagged = '*'; + + new = status_symbol_for_thread(idata->stream, thrd, + cdesc->ctype); + + thrd->branch = save_branch; + } + else{ + mc = (idata->rawno > 0L && idata->stream + && idata->rawno <= idata->stream->nmsgs) + ? mail_elt(idata->stream, idata->rawno) : NULL; + if(mc && mc->valid){ + if(cdesc->ctype == iIStatus || cdesc->ctype == iSIStatus){ + if(mc->recent) + new = mc->seen ? 'R' : 'N'; + else if (!mc->seen) + new = 'U'; + } + else if(!mc->seen + && (!IS_NEWS(idata->stream) + || F_ON(F_FAKE_NEW_IN_NEWS, ps_global))) + new = 'N'; + + if(mc->answered) + answered = 'A'; + + if(mc->deleted) + deleted = 'D'; + + if(mc->flagged) + flagged = '*'; + } + } + + snprintf(str, sizeof(str), "%c %c%c%c%c", to_us, flagged, new, + answered, deleted); + + if(cdesc->ctype == iSIStatus) + start = 2; + else + start = 0; + + ifield->leftadj = 1; + for(i = start; i < 6; i++){ + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->data = (char *) fs_get(2 * sizeof(char)); + ielem->data[0] = str[i]; + ielem->data[1] = '\0'; + ielem->datalen = 1; + set_print_format(ielem, 1, ifield->leftadj); + } + + if(pico_usingcolor()){ + + if(str[0] == '+' || str[0] == '-'){ + if(start == 0 + && VAR_IND_PLUS_FORE_COLOR + && VAR_IND_PLUS_BACK_COLOR){ + ielem = ifield->ielem; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_PLUS_FORE_COLOR, VAR_IND_PLUS_BACK_COLOR); + } + } + + if(str[2] == '*'){ + if(VAR_IND_IMP_FORE_COLOR && VAR_IND_IMP_BACK_COLOR){ + if(start == 2) + ielem = ifield->ielem; + else + ielem = ifield->ielem->next->next; + + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_IMP_FORE_COLOR, VAR_IND_IMP_BACK_COLOR); + } + } + + if(str[3] == 'N' || str[3] == 'n'){ + if(VAR_IND_NEW_FORE_COLOR && VAR_IND_NEW_BACK_COLOR){ + if(start == 2) + ielem = ifield->ielem->next; + else + ielem = ifield->ielem->next->next->next; + + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_NEW_FORE_COLOR, VAR_IND_NEW_BACK_COLOR); + } + } + else if(str[3] == 'R' || str[3] == 'r'){ + if(VAR_IND_REC_FORE_COLOR && VAR_IND_REC_BACK_COLOR){ + if(start == 2) + ielem = ifield->ielem->next; + else + ielem = ifield->ielem->next->next->next; + + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_REC_FORE_COLOR, VAR_IND_REC_BACK_COLOR); + } + } + else if(str[3] == 'U' || str[3] == 'u'){ + if(VAR_IND_UNS_FORE_COLOR && VAR_IND_UNS_BACK_COLOR){ + if(start == 2) + ielem = ifield->ielem->next; + else + ielem = ifield->ielem->next->next->next; + + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_UNS_FORE_COLOR, VAR_IND_UNS_BACK_COLOR); + } + } + + if(str[4] == 'A' || str[4] == 'a'){ + if(VAR_IND_ANS_FORE_COLOR && VAR_IND_ANS_BACK_COLOR){ + if(start == 2) + ielem = ifield->ielem->next->next; + else + ielem = ifield->ielem->next->next->next->next; + + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_ANS_FORE_COLOR, VAR_IND_ANS_BACK_COLOR); + } + } + + if(str[5] == 'D' || str[5] == 'd'){ + if(VAR_IND_DEL_FORE_COLOR && VAR_IND_DEL_BACK_COLOR){ + if(start == 2) + ielem = ifield->ielem->next->next->next; + else + ielem = ifield->ielem->next->next->next->next->next; + + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_DEL_FORE_COLOR, VAR_IND_DEL_BACK_COLOR); + } + } + } + } + + break; + + case iMessNo: + /* + * This is a special case. The message number is + * generated on the fly in the painting routine. + * But the data array is allocated here in case it + * is useful for the paint routine. + */ + snprintf(str, sizeof(str), "%*.*s", ifield->width, ifield->width, " "); + break; + + case iArrow: + snprintf(str, sizeof(str), "%-*.*s", ifield->width, ifield->width, " "); + if(VAR_IND_ARR_FORE_COLOR && VAR_IND_ARR_BACK_COLOR){ + ifield->leftadj = 1; + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->data = cpystr(str); + ielem->datalen = strlen(str); + set_print_format(ielem, ifield->width, ifield->leftadj); + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_ARR_FORE_COLOR, + VAR_IND_ARR_BACK_COLOR); + } + + break; + + case iScore: + score = get_msg_score(idata->stream, idata->rawno); + if(score == SCORE_UNDEF){ + SEARCHSET *ss = NULL; + + ss = mail_newsearchset(); + ss->first = ss->last = (unsigned long) idata->rawno; + if(ss){ + /* + * This looks like it might be expensive to get the + * score for each message when needed but it shouldn't + * be too bad because we know we have the envelope + * data cached. We can't calculate all of the scores + * we need for the visible messages right here in + * one fell swoop because we don't have the other + * envelopes yet. And we can't get the other + * envelopes at this point because we may be in + * the middle of a c-client callback (pine_imap_env). + * (Actually we could, because we know whether or + * not we're in the callback because of the no_fetch + * parameter.) + * We have another problem if the score rules depend + * on something other than envelope data. I guess they + * only do that if they have an alltext (search the + * text of the message) definition. So, we're going + * to pass no_fetch to calculate_scores so that it + * can return an error if we need the text data but + * can't get it because of no_fetch. Setting bogus + * will cause us to do the scores calculation later + * when we are no longer in the callback. + */ + idata->bogus = + (calculate_some_scores(idata->stream, + ss, idata->no_fetch) == 0) + ? 1 : 0; + score = get_msg_score(idata->stream, idata->rawno); + mail_free_searchset(&ss); + } + } + + snprintf(str, sizeof(str), "%ld", score != SCORE_UNDEF ? score : 0L); + break; + + case iDate: case iMonAbb: case iLDate: + case iSDate: case iSTime: + case iS1Date: case iS2Date: case iS3Date: case iS4Date: + case iDateIso: case iDateIsoS: case iTime24: case iTime12: + case iSDateIsoS: case iSDateIso: + case iSDateS1: case iSDateS2: case iSDateS3: case iSDateS4: + case iSDateTime: + case iSDateTimeIsoS: case iSDateTimeIso: + case iSDateTimeS1: case iSDateTimeS2: case iSDateTimeS3: case iSDateTimeS4: + case iSDateTime24: + case iSDateTimeIsoS24: case iSDateTimeIso24: + case iSDateTimeS124: case iSDateTimeS224: case iSDateTimeS324: case iSDateTimeS424: + case iTimezone: case iYear: case iYear2Digit: + case iRDate: case iDay: case iDay2Digit: case iMon2Digit: + case iDayOrdinal: case iMon: case iMonLong: + case iDayOfWeekAbb: case iDayOfWeek: + case iPrefDate: case iPrefTime: case iPrefDateTime: + date_str(fetch_date(idata), cdesc->ctype, 0, str, sizeof(str), cdesc->monabb_width); + break; + + case iFromTo: + case iFromToNotNews: + case iFrom: + case iAddress: + case iMailbox: + fromfield++; + from_str(cdesc->ctype, idata, str, sizeof(str), ice); + break; + + case iTo: + if(((field = ((addr = fetch_to(idata)) + ? "To" + : (addr = fetch_cc(idata)) + ? "Cc" + : NULL)) + && !set_index_addr(idata, field, addr, NULL, BIGWIDTH, str)) + || !field) + if((newsgroups = fetch_newsgroups(idata)) != NULL) + snprintf(str, sizeof(str), "%-.*s", BIGWIDTH, newsgroups); + + break; + + case iCc: + set_index_addr(idata, "Cc", fetch_cc(idata), NULL, BIGWIDTH, str); + break; + + case iRecips: + toaddr = fetch_to(idata); + ccaddr = fetch_cc(idata); + for(last_to = toaddr; + last_to && last_to->next; + last_to = last_to->next) + ; + + /* point end of to list temporarily at cc list */ + if(last_to) + last_to->next = ccaddr; + + set_index_addr(idata, "To", toaddr, NULL, BIGWIDTH, str); + + if(last_to) + last_to->next = NULL; + + break; + + case iSender: + fromfield++; + if((addr = fetch_sender(idata)) != NULL) + set_index_addr(idata, "Sender", addr, NULL, BIGWIDTH, str); + + break; + + case iInit: + {ADDRESS *addr; + + if((addr = fetch_from(idata)) && addr->personal){ + char *name, *initials = NULL; + + name = (char *) rfc1522_decode_to_utf8((unsigned char *)tmp_20k_buf, + SIZEOF_20KBUF, addr->personal); + if(name == addr->personal){ + strncpy(tmp_20k_buf, name, SIZEOF_20KBUF-1); + tmp_20k_buf[SIZEOF_20KBUF - 1] = '\0'; + name = (char *) tmp_20k_buf; + } + + if(name && *name){ + initials = reply_quote_initials(name); + snprintf(str, sizeof(str), "%-.*s", BIGWIDTH, initials); + } + } + } + + break; + + case iSize: + /* 0 ... 9999 */ + if((l = fetch_size(idata)) < 10*1000L) + snprintf(str, sizeof(str), "(%lu)", l); + /* 10K ... 999K */ + else if(l < 1000L*1000L - 1000L/2){ + l = l/1000L + (l%1000L >= 1000L/2 ? 1L : 0L); + snprintf(str, sizeof(str), "(%luK)", l); + } + /* 1.0M ... 99.9M */ + else if(l < 1000L*100L*1000L - 100L*1000L/2){ + l = l/(100L*1000L) + (l%(100L*1000L) >= (100*1000L/2) + ? 1L : 0L); + snprintf(str, sizeof(str), "(%lu.%luM)", l/10L, l % 10L); + } + /* 100M ... 2000M */ + else if(l <= 2*1000L*1000L*1000L){ + l = l/(1000L*1000L) + (l%(1000L*1000L) >= (1000L*1000L/2) + ? 1L : 0L); + snprintf(str, sizeof(str), "(%luM)", l); + } + else + snprintf(str, sizeof(str), "(HUGE!)"); + + break; + + case iSizeComma: + /* 0 ... 99,999 */ + if((l = fetch_size(idata)) < 100*1000L) + snprintf(str, sizeof(str), "(%s)", comatose(l)); + /* 100K ... 9,999K */ + else if(l < 10L*1000L*1000L - 1000L/2){ + l = l/1000L + (l%1000L >= 1000L/2 ? 1L : 0L); + snprintf(str, sizeof(str), "(%sK)", comatose(l)); + } + /* 10.0M ... 999.9M */ + else if(l < 1000L*1000L*1000L - 100L*1000L/2){ + l = l/(100L*1000L) + (l%(100L*1000L) >= (100*1000L/2) + ? 1L : 0L); + snprintf(str, sizeof(str), "(%lu.%luM)", l/10L, l % 10L); + } + /* 1,000M ... 2,000M */ + else if(l <= 2*1000L*1000L*1000L){ + l = l/(1000L*1000L) + (l%(1000L*1000L) >= (1000L*1000L/2) + ? 1L : 0L); + snprintf(str, sizeof(str), "(%sM)", comatose(l)); + } + else + snprintf(str, sizeof(str), "(HUGE!)"); + + break; + + case iSizeNarrow: + /* 0 ... 999 */ + if((l = fetch_size(idata)) < 1000L) + snprintf(str, sizeof(str), "(%lu)", l); + /* 1K ... 99K */ + else if(l < 100L*1000L - 1000L/2){ + l = l/1000L + (l%1000L >= 1000L/2 ? 1L : 0L); + snprintf(str, sizeof(str), "(%luK)", l); + } + /* .1M ... .9M */ + else if(l < 1000L*1000L - 100L*1000L/2){ + l = l/(100L*1000L) + (l%(100L*1000L) >= 100L*1000L/2 + ? 1L : 0L); + snprintf(str, sizeof(str), "(.%luM)", l); + } + /* 1M ... 99M */ + else if(l < 1000L*100L*1000L - 1000L*1000L/2){ + l = l/(1000L*1000L) + (l%(1000L*1000L) >= (1000L*1000L/2) + ? 1L : 0L); + snprintf(str, sizeof(str), "(%luM)", l); + } + /* .1G ... .9G */ + else if(l < 1000L*1000L*1000L - 100L*1000L*1000L/2){ + l = l/(100L*1000L*1000L) + (l%(100L*1000L*1000L) >= + (100L*1000L*1000L/2) ? 1L : 0L); + snprintf(str, sizeof(str), "(.%luG)", l); + } + /* 1G ... 2G */ + else if(l <= 2*1000L*1000L*1000L){ + l = l/(1000L*1000L*1000L) + (l%(1000L*1000L*1000L) >= + (1000L*1000L*1000L/2) ? 1L : 0L); + snprintf(str, sizeof(str), "(%luG)", l); + } + else + snprintf(str, sizeof(str), "(HUGE!)"); + + break; + + /* From Carl Jacobsen <carl@ucsd.edu> */ + case iKSize: + l = fetch_size(idata); + l = (l / 1024L) + (l % 1024L != 0 ? 1 : 0); + + if(l < 1024L) { /* 0k .. 1023k */ + snprintf(str, sizeof(str), "(%luk)", l); + + } else if (l < 100L * 1024L){ /* 1.0M .. 99.9M */ + snprintf(str, sizeof(str), "(%lu.M)", (l * 10L) / 1024L); + if ((p = strchr(str, '.')) != NULL) { + p--; p[1] = p[0]; p[0] = '.'; /* swap last digit & . */ + } + } else if (l <= 2L * 1024L * 1024L) { /* 100M .. 2048 */ + snprintf(str, sizeof(str), "(%luM)", l / 1024L); + } else { + snprintf(str, sizeof(str), "(HUGE!)"); + } + + break; + + case iDescripSize: + if((body = fetch_body(idata)) != NULL) + switch(body->type){ + case TYPETEXT: + { + mc = (idata->rawno > 0L && idata->stream + && idata->rawno <= idata->stream->nmsgs) + ? mail_elt(idata->stream, idata->rawno) : NULL; + if(mc && mc->rfc822_size < 6000) + snprintf(str, sizeof(str), "(short )"); + else if(mc && mc->rfc822_size < 25000) + snprintf(str, sizeof(str), "(medium )"); + else if(mc && mc->rfc822_size < 100000) + snprintf(str, sizeof(str), "(long )"); + else + snprintf(str, sizeof(str), "(huge )"); + } + + break; + + case TYPEMULTIPART: + if(strucmp(body->subtype, "MIXED") == 0){ + int x; + + x = body->nested.part + ? body->nested.part->body.type + : TYPETEXT + 1000; + switch(x){ + case TYPETEXT: + if(body->nested.part->body.size.bytes < 6000) + snprintf(str, sizeof(str), "(short+ )"); + else if(body->nested.part->body.size.bytes + < 25000) + snprintf(str, sizeof(str), "(medium+)"); + else if(body->nested.part->body.size.bytes + < 100000) + snprintf(str, sizeof(str), "(long+ )"); + else + snprintf(str, sizeof(str), "(huge+ )"); + break; + + default: + snprintf(str, sizeof(str), "(multi )"); + break; + } + } + else if(strucmp(body->subtype, "DIGEST") == 0) + snprintf(str, sizeof(str), "(digest )"); + else if(strucmp(body->subtype, "ALTERNATIVE") == 0) + snprintf(str, sizeof(str), "(mul/alt)"); + else if(strucmp(body->subtype, "PARALLEL") == 0) + snprintf(str, sizeof(str), "(mul/par)"); + else + snprintf(str, sizeof(str), "(multi )"); + + break; + + case TYPEMESSAGE: + snprintf(str, sizeof(str), "(message)"); + break; + + case TYPEAPPLICATION: + snprintf(str, sizeof(str), "(applica)"); + break; + + case TYPEAUDIO: + snprintf(str, sizeof(str), "(audio )"); + break; + + case TYPEIMAGE: + snprintf(str, sizeof(str), "(image )"); + break; + + case TYPEVIDEO: + snprintf(str, sizeof(str), "(video )"); + break; + + default: + snprintf(str, sizeof(str), "(other )"); + break; + } + + break; + + case iAtt: + str[0] = SPACE; + str[1] = '\0'; + if((body = fetch_body(idata)) && + body->type == TYPEMULTIPART && + strucmp(body->subtype, "ALTERNATIVE") != 0){ + PART *part; + int atts = 0; + + part = body->nested.part; /* 1st part, don't count */ + while(part && part->next && atts < 10){ + atts++; + part = part->next; + } + + if(atts > 9) + str[0] = '*'; + else if(atts > 0) + str[0] = '0' + atts; + } + + break; + + case iSubject: + subj_str(idata, str, sizeof(str), NoKW, 0, ice); + break; + + case iSubjectText: + subj_str(idata, str, sizeof(str), NoKW, 1, ice); + break; + + case iSubjKey: + subj_str(idata, str, sizeof(str), KW, 0, ice); + break; + + case iSubjKeyText: + subj_str(idata, str, sizeof(str), KW, 1, ice); + break; + + case iSubjKeyInit: + subj_str(idata, str, sizeof(str), KWInit, 0, ice); + break; + + case iSubjKeyInitText: + subj_str(idata, str, sizeof(str), KWInit, 1, ice); + break; + + case iOpeningText: + case iOpeningTextNQ: + if(idata->no_fetch) + idata->bogus = 1; + else{ + char *first_text; + + first_text = fetch_firsttext(idata, cdesc->ctype == iOpeningTextNQ); + + if(first_text){ + strncpy(str, first_text, BIGWIDTH); + str[BIGWIDTH] = '\0'; + fs_give((void **) &first_text); + } + } + + break; + + case iKey: + key_str(idata, KW, ice); + break; + + case iKeyInit: + key_str(idata, KWInit, ice); + break; + + case iNews: + if((newsgroups = fetch_newsgroups(idata)) != NULL){ + strncpy(str, newsgroups, BIGWIDTH); + str[BIGWIDTH] = '\0'; + } + + break; + + case iNewsAndTo: + if((newsgroups = fetch_newsgroups(idata)) != NULL) + strncpy(str, newsgroups, sizeof(str)); + + if((l = strlen(str)) < sizeof(str)){ + if(sizeof(str) - l < 6) + strncpy(str+l, "...", sizeof(str)-l); + else{ + if(l > 0){ + strncpy(str+l, " and ", sizeof(str)-l); + set_index_addr(idata, "To", fetch_to(idata), + NULL, BIGWIDTH-l-5, str+l+5); + if(!str[l+5]) + str[l] = '\0'; + } + else + set_index_addr(idata, "To", fetch_to(idata), + NULL, BIGWIDTH, str); + } + } + + break; + + case iToAndNews: + set_index_addr(idata, "To", fetch_to(idata), + NULL, BIGWIDTH, str); + if((l = strlen(str)) < sizeof(str) && + (newsgroups = fetch_newsgroups(idata))){ + if(sizeof(str) - l < 6) + strncpy(str+l, "...", sizeof(str)-l); + else{ + if(l > 0) + strncpy(str+l, " and ", sizeof(str)-l); + + if(l > 0) + strncpy(str+l+5, newsgroups, BIGWIDTH-l-5); + else + strncpy(str, newsgroups, BIGWIDTH); + } + } + + break; + + case iNewsAndRecips: + if((newsgroups = fetch_newsgroups(idata)) != NULL) + strncpy(str, newsgroups, BIGWIDTH); + + if((l = strlen(str)) < BIGWIDTH){ + if(BIGWIDTH - l < 6) + strncpy(str+l, "...", BIGWIDTH-l); + else{ + toaddr = fetch_to(idata); + ccaddr = fetch_cc(idata); + for(last_to = toaddr; + last_to && last_to->next; + last_to = last_to->next) + ; + + /* point end of to list temporarily at cc list */ + if(last_to) + last_to->next = ccaddr; + + if(l > 0){ + strncpy(str+l, " and ", sizeof(str)-l); + set_index_addr(idata, "To", toaddr, + NULL, BIGWIDTH-l-5, str+l+5); + if(!str[l+5]) + str[l] = '\0'; + } + else + set_index_addr(idata, "To", toaddr, NULL, BIGWIDTH, str); + + if(last_to) + last_to->next = NULL; + } + } + + break; + + case iRecipsAndNews: + toaddr = fetch_to(idata); + ccaddr = fetch_cc(idata); + for(last_to = toaddr; + last_to && last_to->next; + last_to = last_to->next) + ; + + /* point end of to list temporarily at cc list */ + if(last_to) + last_to->next = ccaddr; + + set_index_addr(idata, "To", toaddr, NULL, BIGWIDTH, str); + + if(last_to) + last_to->next = NULL; + + if((l = strlen(str)) < BIGWIDTH && + (newsgroups = fetch_newsgroups(idata))){ + if(BIGWIDTH - l < 6) + strncpy(str+l, "...", BIGWIDTH-l); + else{ + if(l > 0) + strncpy(str+l, " and ", sizeof(str)-l); + + if(l > 0) + strncpy(str+l+5, newsgroups, BIGWIDTH-l-5); + else + strncpy(str, newsgroups, BIGWIDTH); + } + } + + break; + + case iPrio: + case iPrioAlpha: + case iPrioBang: + prio_str(idata, cdesc->ctype, ice); + break; + + case iHeader: + header_str(idata, cdesc->hdrtok, ice); + break; + + case iText: + strncpy(str, (cdesc->hdrtok && cdesc->hdrtok->hdrname) ? cdesc->hdrtok->hdrname : "", sizeof(str)); + str[sizeof(str)-1] = '\0'; + break; + + default: + break; + } + + /* + * If the element wasn't already filled in above, do it here. + */ + if(!ifield->ielem){ + ielem = new_ielem(&ifield->ielem); + + ielem->freedata = 1; + ielem->data = cpystr(str); + ielem->datalen = strlen(str); + + if(fromfield && pico_usingcolor() + && ps_global->VAR_IND_FROM_FORE_COLOR + && ps_global->VAR_IND_FROM_BACK_COLOR){ + ielem->type = eTypeCol; + ielem->freecolor = 1; + ielem->color = new_color_pair(ps_global->VAR_IND_FROM_FORE_COLOR, + ps_global->VAR_IND_FROM_BACK_COLOR); + /* + * This space is here so that if the text does + * not extend all the way to the end of the field then + * we'll switch the color back and paint the rest of the + * field in the Normal color or the index line color. + */ + ielem = new_ielem(&ielem); + ielem->freedata = 1; + ielem->data = cpystr(" "); + ielem->datalen = 1; + } + else if((cdesc->ctype == iOpeningText || cdesc->ctype == iOpeningTextNQ) + && pico_usingcolor() + && ps_global->VAR_IND_OP_FORE_COLOR + && ps_global->VAR_IND_OP_BACK_COLOR){ + ielem->type = eTypeCol; + ielem->freecolor = 1; + ielem->color = new_color_pair(ps_global->VAR_IND_OP_FORE_COLOR, + ps_global->VAR_IND_OP_BACK_COLOR); + /* + * This space is here so that if the text does + * not extend all the way to the end of the field then + * we'll switch the color back and paint the rest of the + * field in the Normal color or the index line color. + */ + ielem = new_ielem(&ielem); + ielem->freedata = 1; + ielem->data = cpystr(" "); + ielem->datalen = 1; + } + + ifield->leftadj = (cdesc->adjustment == Left) ? 1 : 0; + set_ielem_widths_in_field(ifield); + } + } + + ice->widths_done = 1; + ice->id = ice_hash(ice); + + /* + * Now we have to put the temporary copy of ice back as the + * real thing. + */ + icep = fetch_ice_ptr(idata->stream, idata->rawno); + if(icep){ + free_ice(icep); /* free what is already there */ + *icep = ice; + } + + return(ice); +} + + +ICE_S * +format_thread_index_line(INDEXDATA_S *idata) +{ + char *p, buffer[BIGWIDTH+1]; + int thdlen, space_left, i; + PINETHRD_S *thrd = NULL; + ICE_S *ice, *tice = NULL, **ticep = NULL; + IFIELD_S *ifield; + IELEM_S *ielem; + int (*save_sfstr_func)(void); + struct variable *vars = ps_global->vars; + + dprint((8, "=== format_thread_index_line(%ld,%ld) ===\n", + idata ? idata->msgno : -1, idata ? idata->rawno : -1)); + + space_left = ps_global->ttyo->screen_cols; + + if(ps_global->msgmap->max_thrdno < 1000) + thdlen = 3; + else if(ps_global->msgmap->max_thrdno < 10000) + thdlen = 4; + else if(ps_global->msgmap->max_thrdno < 100000) + thdlen = 5; + else + thdlen = 6; + + ice = fetch_ice(idata->stream, idata->rawno); + + thrd = fetch_thread(idata->stream, idata->rawno); + + if(!thrd || !ice) /* can't happen? */ + return(ice); + + if(!ice->tice){ + tice = (ICE_S *) fs_get(sizeof(*tice)); + memset(tice, 0, sizeof(*tice)); + ice->tice = tice; + } + + tice = ice->tice; + + if(!tice) + return(ice); + + free_ifield(&tice->ifield); + + ticep = &ice->tice; + tice = copy_ice(tice); + + if(space_left >= 3){ + char to_us, status; + + p = buffer; + to_us = to_us_symbol_for_thread(idata->stream, thrd, 1); + status = status_symbol_for_thread(idata->stream, thrd, iStatus); + + if((p-buffer)+3 < sizeof(buffer)){ + p[0] = to_us; + p[1] = ' '; + p[2] = status; + p[3] = '\0';; + } + + space_left -= 3; + + ifield = new_ifield(&tice->ifield); + ifield->ctype = iStatus; + ifield->width = 3; + ifield->leftadj = 1; + for(i = 0; i < 3; i++){ + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->data = (char *) fs_get(2 * sizeof(char)); + ielem->data[0] = p[i]; + ielem->data[1] = '\0'; + ielem->datalen = 1; + set_print_format(ielem, 1, ifield->leftadj); + } + + if(pico_usingcolor()){ + if(to_us == '*' + && VAR_IND_IMP_FORE_COLOR && VAR_IND_IMP_BACK_COLOR){ + ielem = ifield->ielem; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_IMP_FORE_COLOR, + VAR_IND_IMP_BACK_COLOR); + if(F_ON(F_COLOR_LINE_IMPORTANT, ps_global)) + tice->linecolor = new_color_pair(VAR_IND_IMP_FORE_COLOR, + VAR_IND_IMP_BACK_COLOR); + } + else if((to_us == '+' || to_us == '-') + && VAR_IND_PLUS_FORE_COLOR && VAR_IND_PLUS_BACK_COLOR){ + ielem = ifield->ielem; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_PLUS_FORE_COLOR, + VAR_IND_PLUS_BACK_COLOR); + } + + if(status == 'D' + && VAR_IND_DEL_FORE_COLOR && VAR_IND_DEL_BACK_COLOR){ + ielem = ifield->ielem->next->next; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_DEL_FORE_COLOR, + VAR_IND_DEL_BACK_COLOR); + } + else if(status == 'N' + && VAR_IND_NEW_FORE_COLOR && VAR_IND_NEW_BACK_COLOR){ + ielem = ifield->ielem->next->next; + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_NEW_FORE_COLOR, + VAR_IND_NEW_BACK_COLOR); + } + } + } + + if(space_left >= thdlen+1){ + p = buffer; + space_left--; + + snprintf(p, sizeof(buffer), "%*.*s", thdlen, thdlen, ""); + space_left -= thdlen; + + ifield = new_ifield(&tice->ifield); + ifield->ctype = iMessNo; + ifield->width = thdlen; + ifield->leftadj = 0; + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->data = cpystr(p); + ielem->datalen = strlen(p); + set_print_format(ielem, ifield->width, ifield->leftadj); + } + + if(space_left >= 7){ + + p = buffer; + space_left--; + + date_str(fetch_date(idata), iDate, 0, p, sizeof(buffer), 0); + if(sizeof(buffer) > 6) + p[6] = '\0'; + + if(strlen(p) < 6 && (sizeof(buffer)) > 6){ + char *q; + + for(q = p + strlen(p); q < p + 6; q++) + *q = ' '; + } + + space_left -= 6; + + ifield = new_ifield(&tice->ifield); + ifield->ctype = iDate; + ifield->width = 6; + ifield->leftadj = 1; + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->data = cpystr(p); + ielem->datalen = ifield->width; + set_print_format(ielem, ifield->width, ifield->leftadj); + } + + + if(space_left > 3){ + int from_width, subj_width, bigthread_adjust; + long in_thread; + char from[BIGWIDTH+1]; + char tcnt[50]; + + space_left--; + + in_thread = count_lflags_in_thread(idata->stream, thrd, + ps_global->msgmap, MN_NONE); + + p = buffer; + if(in_thread == 1 && THRD_AUTO_VIEW()) + snprintf(tcnt, sizeof(tcnt), " "); + else + snprintf(tcnt, sizeof(tcnt), "(%ld)", in_thread); + + bigthread_adjust = MAX(0, strlen(tcnt) - 3); + + /* third of the rest */ + from_width = MAX((space_left-1)/3 - bigthread_adjust, 1); + + /* the rest */ + subj_width = space_left - from_width - 1; + + if(strlen(tcnt) > subj_width) + tcnt[subj_width] = '\0'; + + from[0] = '\0'; + save_sfstr_func = pith_opt_truncate_sfstr; + pith_opt_truncate_sfstr = NULL; + from_str(iFromTo, idata, from, sizeof(from), tice); + pith_opt_truncate_sfstr = save_sfstr_func; + + ifield = new_ifield(&tice->ifield); + ifield->leftadj = 1; + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->type = eTypeCol; + ielem->data = cpystr(from); + ielem->datalen = strlen(from); + ifield->width = from_width; + set_print_format(ielem, ifield->width, ifield->leftadj); + ifield->ctype = iFrom; + if(from_width > 0 && pico_usingcolor() + && VAR_IND_FROM_FORE_COLOR && VAR_IND_FROM_BACK_COLOR){ + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_FROM_FORE_COLOR, + VAR_IND_FROM_BACK_COLOR); + } + + ifield = new_ifield(&tice->ifield); + ifield->leftadj = 0; + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->data = cpystr(tcnt); + ielem->datalen = strlen(tcnt); + ifield->width = ielem->datalen; + set_print_format(ielem, ifield->width, ifield->leftadj); + ifield->ctype = iAtt; /* not used, except that it isn't special */ + + subj_width -= strlen(tcnt); + + if(subj_width > 0) + subj_width--; + + if(subj_width > 0){ + if(idata->bogus){ + if(idata->bogus < 2) + snprintf(buffer, sizeof(buffer), "%-.*s", BIGWIDTH, + _("[ No Message Text Available ]")); + } + else{ + buffer[0] = '\0'; + save_sfstr_func = pith_opt_truncate_sfstr; + pith_opt_truncate_sfstr = NULL; + subj_str(idata, buffer, sizeof(buffer), NoKW, 0, NULL); + pith_opt_truncate_sfstr = save_sfstr_func; + } + + ifield = new_ifield(&tice->ifield); + ifield->leftadj = 1; + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->type = eTypeCol; + ielem->data = cpystr(buffer); + ielem->datalen = strlen(buffer); + ifield->width = subj_width; + set_print_format(ielem, ifield->width, ifield->leftadj); + ifield->ctype = iSubject; + if(pico_usingcolor() && VAR_IND_SUBJ_FORE_COLOR && VAR_IND_SUBJ_BACK_COLOR){ + ielem->freecolor = 1; + ielem->color = new_color_pair(VAR_IND_SUBJ_FORE_COLOR, + VAR_IND_SUBJ_BACK_COLOR); + } + } + } + else if(space_left > 1){ + snprintf(p, sizeof(buffer)-(p-buffer), "%-.*s", space_left-1, " "); + ifield = new_ifield(&tice->ifield); + ifield->leftadj = 1; + ielem = new_ielem(&ifield->ielem); + ielem->freedata = 1; + ielem->data = cpystr(p); + ielem->datalen = strlen(p); + ifield->width = space_left-1; + set_print_format(ielem, ifield->width, ifield->leftadj); + ifield->ctype = iSubject; + } + + tice->widths_done = 1; + tice->id = ice_hash(tice); + + if(ticep){ + free_ice(ticep); /* free what is already there */ + *ticep = tice; + } + + return(ice); +} + + +/* + * Print the fields of ice in buf with a single space between fields. + * + * Args buf -- place to put the line + * ice -- the data for the line + * msgno -- this is the msgno to be used, blanks if <= 0 + * + * Returns a pointer to buf. + */ +char * +simple_index_line(char *buf, size_t buflen, ICE_S *ice, long int msgno) +{ + char *p; + IFIELD_S *ifield, *previfield = NULL; + IELEM_S *ielem; + + if(!buf) + panic("NULL buf in simple_index_line()"); + + if(buflen > 0) + buf[0] = '\0'; + + p = buf; + + if(ice){ + + for(ifield = ice->ifield; ifield && p-buf < buflen; ifield = ifield->next){ + + /* space between fields */ + if(ifield != ice->ifield && !(previfield && previfield->ctype == iText)) + *p++ = ' '; + + /* message number string is generated on the fly */ + if(ifield->ctype == iMessNo){ + ielem = ifield->ielem; + if(ielem && ielem->datalen >= ifield->width){ + if(msgno > 0L) + snprintf(ielem->data, ielem->datalen+1, "%*.ld", ifield->width, msgno); + else + snprintf(ielem->data, ielem->datalen+1, "%*.*s", ifield->width, ifield->width, ""); + } + } + + for(ielem = ifield->ielem; + ielem && ielem->print_format && p-buf < buflen; + ielem = ielem->next){ + char *src; + size_t bytes_added; + + src = ielem->data; + bytes_added = utf8_pad_to_width(p, src, + buflen-(p-buf) * sizeof(char), + ielem->wid, ifield->leftadj); + p += bytes_added; + } + + previfield = ifield; + } + + if(p-buf < buflen) + *p = '\0'; + } + + buf[buflen-1] = '\0'; + + return(buf); +} + + +/* + * Look in current mail_stream for matches for messages in the searchset + * which match a color rule pattern. Return the color. + * The searched bit will be set for all of the messages which match the + * first pattern which has a match. + * + * Args stream -- the mail stream + * searchset -- restrict attention to this set of messages + * pstate -- The pattern state. On the first call it will be Null. + * Null means start over with a new first_pattern. + * After that it will be pointing to our local PAT_STATE + * so that next_pattern goes to the next one after the + * ones we've already checked. + * + * Returns 0 if no match, 1 if a match. + * The color that goes with the matched rule in returned_color. + * It may be NULL, which indicates default. + */ +int +get_index_line_color(MAILSTREAM *stream, SEARCHSET *searchset, + PAT_STATE **pstate, COLOR_PAIR **returned_color) +{ + PAT_S *pat = NULL; + long rflags = ROLE_INCOL; + COLOR_PAIR *color = NULL; + int match = 0; + static PAT_STATE localpstate; + + dprint((7, "get_index_line_color\n")); + + if(returned_color) + *returned_color = NULL; + + if(*pstate) + pat = next_pattern(*pstate); + else{ + *pstate = &localpstate; + if(!nonempty_patterns(rflags, *pstate)) + *pstate = NULL; + + if(*pstate) + pat = first_pattern(*pstate); + } + + if(*pstate){ + + /* Go through the possible roles one at a time until we get a match. */ + while(!match && pat){ + if(match_pattern(pat->patgrp, stream, searchset, NULL, + get_msg_score, SE_NOSERVER|SE_NOPREFETCH)){ + if(!pat->action || pat->action->bogus) + break; + + match++; + if(pat->action && pat->action->incol) + color = new_color_pair(pat->action->incol->fg, + pat->action->incol->bg); + } + else + pat = next_pattern(*pstate); + } + } + + if(match && returned_color) + *returned_color = color; + + return(match); +} + + +/* + * + */ +int +index_in_overview(MAILSTREAM *stream) +{ + INDEX_COL_S *cdesc = NULL; + + if(!(stream->mailbox && IS_REMOTE(stream->mailbox))) + return(FALSE); /* no point! */ + + if(stream->dtb && stream->dtb->name && !strcmp(stream->dtb->name, "nntp")){ + + if(THRD_INDX()) + return(TRUE); + + for(cdesc = ps_global->index_disp_format; + cdesc->ctype != iNothing; + cdesc++) + switch(cdesc->ctype){ + case iTo: /* can't be satisfied by XOVER */ + case iSender: /* ... or specifically handled */ + case iDescripSize: /* ... in news case */ + case iAtt: + return(FALSE); + + default : + break; + } + } + + return(TRUE); +} + + + +/* + * fetch_from - called to get a the index entry's "From:" field + */ +int +resent_to_us(INDEXDATA_S *idata) +{ + if(!idata->valid_resent_to){ + static char *fields[] = {"Resent-To", NULL}; + char *h; + + if(idata->no_fetch){ + idata->bogus = 1; /* don't do this */ + return(FALSE); + } + + if((h = pine_fetchheader_lines(idata->stream,idata->rawno,NULL,fields)) != NULL){ + idata->resent_to_us = parsed_resent_to_us(h); + fs_give((void **) &h); + } + + idata->valid_resent_to = 1; + } + + return(idata->resent_to_us); +} + + +int +parsed_resent_to_us(char *h) +{ + char *p, *q; + ADDRESS *addr = NULL; + int rv = FALSE; + + if((p = strindex(h, ':')) != NULL){ + for(q = ++p; (q = strpbrk(q, "\015\012")) != NULL; q++) + *q = ' '; /* quash junk */ + + rfc822_parse_adrlist(&addr, p, ps_global->maildomain); + if(addr){ + rv = address_is_us(addr, ps_global); + mail_free_address(&addr); + } + } + + return(rv); +} + + + +/* + * fetch_from - called to get a the index entry's "From:" field + */ +ADDRESS * +fetch_from(INDEXDATA_S *idata) +{ + if(idata->no_fetch) /* implies from is valid */ + return(idata->from); + else if(idata->bogus) + idata->bogus = 2; + else{ + ENVELOPE *env; + + /* c-client call's just cache access at this point */ + if((env = pine_mail_fetchenvelope(idata->stream, idata->rawno)) != NULL) + return(env->from); + + idata->bogus = 1; + } + + return(NULL); +} + + +/* + * fetch_to - called to get a the index entry's "To:" field + */ +ADDRESS * +fetch_to(INDEXDATA_S *idata) +{ + if(idata->no_fetch){ /* check for specific validity */ + if(idata->valid_to) + return(idata->to); + else + idata->bogus = 1; /* can't give 'em what they want */ + } + else if(idata->bogus){ + idata->bogus = 2; /* elevate bogosity */ + } + else{ + ENVELOPE *env; + + /* c-client call's just cache access at this point */ + if((env = pine_mail_fetchenvelope(idata->stream, idata->rawno)) != NULL) + return(env->to); + + idata->bogus = 1; + } + + return(NULL); +} + + +/* + * fetch_cc - called to get a the index entry's "Cc:" field + */ +ADDRESS * +fetch_cc(INDEXDATA_S *idata) +{ + if(idata->no_fetch){ /* check for specific validity */ + if(idata->valid_cc) + return(idata->cc); + else + idata->bogus = 1; /* can't give 'em what they want */ + } + else if(idata->bogus){ + idata->bogus = 2; /* elevate bogosity */ + } + else{ + ENVELOPE *env; + + /* c-client call's just cache access at this point */ + if((env = pine_mail_fetchenvelope(idata->stream, idata->rawno)) != NULL) + return(env->cc); + + idata->bogus = 1; + } + + return(NULL); +} + + + +/* + * fetch_sender - called to get a the index entry's "Sender:" field + */ +ADDRESS * +fetch_sender(INDEXDATA_S *idata) +{ + if(idata->no_fetch){ /* check for specific validity */ + if(idata->valid_sender) + return(idata->sender); + else + idata->bogus = 1; /* can't give 'em what they want */ + } + else if(idata->bogus){ + idata->bogus = 2; /* elevate bogosity */ + } + else{ + ENVELOPE *env; + + /* c-client call's just cache access at this point */ + if((env = pine_mail_fetchenvelope(idata->stream, idata->rawno)) != NULL) + return(env->sender); + + idata->bogus = 1; + } + + return(NULL); +} + + +/* + * fetch_newsgroups - called to get a the index entry's "Newsgroups:" field + */ +char * +fetch_newsgroups(INDEXDATA_S *idata) +{ + if(idata->no_fetch){ /* check for specific validity */ + if(idata->valid_news) + return(idata->newsgroups); + else + idata->bogus = 1; /* can't give 'em what they want */ + } + else if(idata->bogus){ + idata->bogus = 2; /* elevate bogosity */ + } + else{ + ENVELOPE *env; + + /* c-client call's just cache access at this point */ + if((env = pine_mail_fetchenvelope(idata->stream, idata->rawno)) != NULL) + return(env->newsgroups); + + idata->bogus = 1; + } + + return(NULL); +} + + +/* + * fetch_subject - called to get at the index entry's "Subject:" field + */ +char * +fetch_subject(INDEXDATA_S *idata) +{ + if(idata->no_fetch) /* implies subject is valid */ + return(idata->subject); + else if(idata->bogus) + idata->bogus = 2; + else{ + ENVELOPE *env; + + /* c-client call's just cache access at this point */ + if((env = pine_mail_fetchenvelope(idata->stream, idata->rawno)) != NULL) + return(env->subject); + + idata->bogus = 1; + } + + return(NULL); +} + + +/* + * Return an allocated copy of the first few characters from the body + * of the message for possible use in the index screen. + * + * Maybe we could figure out some way to do aggregate calls to get + * this info for all the lines in view instead of all the one at a + * time calls we're doing now. + */ +char * +fetch_firsttext(INDEXDATA_S *idata, int delete_quotes) +{ + ENVELOPE *env; + BODY *body = NULL; + char *firsttext = NULL; + STORE_S *so; + gf_io_t pc; + long partial_fetch_len = 0L; + SEARCHSET *ss, **sset; + +try_again: + + /* + * Prevent wild prefetch, just get the one we're after. + * Can we get this somehow in the overview call in build_header_work? + */ + ss = mail_newsearchset(); + ss->first = idata->rawno; + sset = (SEARCHSET **) mail_parameters(idata->stream, + GET_FETCHLOOKAHEAD, + (void *) idata->stream); + if(sset) + *sset = ss; + + if((env = pine_mail_fetchstructure(idata->stream, idata->rawno, &body)) != NULL){ + if(body){ + char *subtype = NULL; + char *partno; + + if((body->type == TYPETEXT + && (subtype=body->subtype) && ALLOWED_SUBTYPE(subtype)) + || + (body->type == TYPEMULTIPART && body->nested.part + && body->nested.part->body.type == TYPETEXT + && (subtype=body->nested.part->body.subtype) + && ALLOWED_SUBTYPE(subtype)) + || + (body->type == TYPEMULTIPART && body->nested.part + && body->nested.part->body.type == TYPEMULTIPART + && body->nested.part->body.nested.part + && body->nested.part->body.nested.part->body.type == TYPETEXT + && (subtype=body->nested.part->body.nested.part->body.subtype) + && ALLOWED_SUBTYPE(subtype))){ + + if((so = so_get(CharStar, NULL, EDIT_ACCESS)) != NULL){ + char buf[1025], *p; + unsigned char c; + int success; + int one_space_done = 0; + + if(partial_fetch_len == 0L){ + if(subtype && !strucmp(subtype, "html")) + partial_fetch_len = 1024L; + else if(subtype && !strucmp(subtype, "plain")) + partial_fetch_len = delete_quotes ? 128L : 64L; + else + partial_fetch_len = 256L; + } + + if((body->type == TYPETEXT + && (subtype=body->subtype) && ALLOWED_SUBTYPE(subtype)) + || + (body->type == TYPEMULTIPART && body->nested.part + && body->nested.part->body.type == TYPETEXT + && (subtype=body->nested.part->body.subtype) + && ALLOWED_SUBTYPE(subtype))) + partno = "1"; + else + partno = "1.1"; + + gf_set_so_writec(&pc, so); + success = get_body_part_text(idata->stream, body, idata->rawno, + partno, partial_fetch_len, pc, + NULL, NULL, + GBPT_NOINTR | GBPT_PEEK | + (delete_quotes ? GBPT_DELQUOTES : 0)); + gf_clear_so_writec(so); + + if(success){ + so_seek(so, 0L, 0); + p = buf; + while(p-buf < sizeof(buf)-1 && so_readc(&c, so)){ + /* delete leading whitespace */ + if(p == buf && isspace(c)) + ; + /* and include just one space per run of whitespace */ + else if(isspace(c)){ + if(!one_space_done){ + *p++ = SPACE; + one_space_done++; + } + } + else{ + one_space_done = 0; + *p++ = c; + } + } + + *p = '\0'; + + if(p > buf){ + size_t l; + + l = strlen(buf); + l += 100; + firsttext = fs_get((l+1) * sizeof(char)); + firsttext[0] = '\0'; + iutf8ncpy(firsttext, buf, l); + firsttext[l] = '\0'; + removing_trailing_white_space(firsttext); + } + } + + so_give(&so); + + /* first if means we didn't fetch all of the data */ + if(!(success > 1 && success < partial_fetch_len)){ + if(partial_fetch_len < 4096L + && (!firsttext || utf8_width(firsttext) < 50)){ + if(firsttext) + fs_give((void **) &firsttext); + + partial_fetch_len = 4096L; + goto try_again; + } + } + } + } + } + } + + if(ss) + mail_free_searchset(&ss); + + return(firsttext); +} + + +/* + * fetch_date - called to get at the index entry's "Date:" field + */ +char * +fetch_date(INDEXDATA_S *idata) +{ + if(idata->no_fetch) /* implies date is valid */ + return(idata->date); + else if(idata->bogus) + idata->bogus = 2; + else{ + ENVELOPE *env; + + /* c-client call's just cache access at this point */ + if((env = pine_mail_fetchenvelope(idata->stream, idata->rawno)) != NULL) + return((char *) env->date); + + idata->bogus = 1; + } + + return(NULL); +} + + +/* + * fetch_header - called to get at the index entry's "Hdrname:" field + */ +char * +fetch_header(INDEXDATA_S *idata, char *hdrname) +{ + if(idata->no_fetch) + idata->bogus = 1; + else if(idata->bogus) + idata->bogus = 2; + else{ + char *h, *p, *q, *decoded, *fields[2]; + size_t retsize, decsize; + char *ret = NULL; + unsigned char *decode_buf = NULL; + + fields[0] = hdrname; + fields[1] = NULL; + if(hdrname && hdrname[0] + && (h = pine_fetchheader_lines(idata->stream, idata->rawno, + NULL, fields))){ + + if(strlen(h) < strlen(hdrname) + 1){ + fs_give((void **) &h); + return(cpystr("")); + } + + /* skip "hdrname:" */ + for(p = h + strlen(hdrname) + 1; + *p && isspace((unsigned char)*p); p++) + ; + + decsize = (4 * strlen(p)) + 1; + decode_buf = (unsigned char *) fs_get(decsize * sizeof(unsigned char)); + decoded = (char *) rfc1522_decode_to_utf8(decode_buf, decsize, p); + p = decoded; + + retsize = strlen(decoded); + q = ret = (char *) fs_get((retsize+1) * sizeof(char)); + + *q = '\0'; + while(q-ret < retsize && *p){ + if(*p == '\015' || *p == '\012') + p++; + else if(*p == '\t'){ + *q++ = SPACE; + p++; + } + else + *q++ = *p++; + } + + *q = '\0'; + + fs_give((void **) &h); + if(decode_buf) + fs_give((void **) &decode_buf); + + return(ret); + } + + idata->bogus = 1; + } + + return(NULL); +} + + +/* + * fetch_size - called to get at the index entry's "size" field + */ +long +fetch_size(INDEXDATA_S *idata) +{ + if(idata->no_fetch) /* implies size is valid */ + return(idata->size); + else if(idata->bogus) + idata->bogus = 2; + else{ + MESSAGECACHE *mc; + + if(idata->stream && idata->rawno > 0L + && idata->rawno <= idata->stream->nmsgs + && (mc = mail_elt(idata->stream, idata->rawno))) + return(mc->rfc822_size); + + idata->bogus = 1; + } + + return(0L); +} + + +/* + * fetch_body - called to get a the index entry's body structure + */ +BODY * +fetch_body(INDEXDATA_S *idata) +{ + BODY *body; + + if(idata->bogus || idata->no_fetch){ + idata->bogus = 2; + return(NULL); + } + + if(pine_mail_fetchstructure(idata->stream, idata->rawno, &body)) + return(body); + + idata->bogus = 1; + return(NULL); +} + + +/* + * s is at least size width+1 + */ +int +set_index_addr(INDEXDATA_S *idata, + char *field, + struct mail_address *addr, + char *prefix, + int width, + char *s) +{ + ADDRESS *atmp; + char *p, *stmp = NULL, *sptr; + char *save_personal = NULL; + int orig_width; + + s[0] = '\0'; + + for(atmp = addr; idata->stream && atmp; atmp = atmp->next) + if(atmp->host && atmp->host[0] == '.'){ + char *pref, *h, *fields[2]; + + if(idata->no_fetch){ + idata->bogus = 1; + return(TRUE); + } + + fields[0] = field; + fields[1] = NULL; + if((h = pine_fetchheader_lines(idata->stream, idata->rawno, + NULL, fields)) != NULL){ + if(strlen(h) < strlen(field) + 1){ + p = h + strlen(h); + } + else{ + /* skip "field:" */ + for(p = h + strlen(field) + 1; + *p && isspace((unsigned char)*p); p++) + ; + } + + orig_width = width; + sptr = stmp = (char *) fs_get((orig_width+1) * sizeof(char)); + + /* add prefix */ + for(pref = prefix; pref && *pref; pref++) + if(width){ + *sptr++ = *pref; + width--; + } + else + break; + + while(width--) + if(*p == '\015' || *p == '\012') + p++; /* skip CR LF */ + else if(!*p) + *sptr++ = ' '; + else if(*p == '\t'){ + *sptr++ = ' '; + p++; + } + else + *sptr++ = *p++; + + *sptr = '\0'; /* tie off return string */ + + if(stmp){ + iutf8ncpy(s, stmp, orig_width+1); + s[orig_width] = '\0'; + fs_give((void **) &stmp); + } + + fs_give((void **) &h); + return(TRUE); + } + /* else fall thru and display what c-client gave us */ + } + + if(addr && !addr->next /* only one address */ + && addr->host /* not group syntax */ + && addr->personal && addr->personal[0]){ /* there is a personal name */ + char buftmp[MAILTMPLEN]; + int l; + + if((l = prefix ? strlen(prefix) : 0) != 0) + strncpy(s, prefix, width+1); + + snprintf(buftmp, sizeof(buftmp), "%s", addr->personal); + p = (char *) rfc1522_decode_to_utf8((unsigned char *) tmp_20k_buf, + SIZEOF_20KBUF, buftmp); + removing_leading_and_trailing_white_space(p); + + iutf8ncpy(s + l, p, width - l); + + s[width] = '\0'; + + if(*(s+l)) + return(TRUE); + else{ + save_personal = addr->personal; + addr->personal = NULL; + } + } + + if(addr){ + char *a_string; + int l; + + a_string = addr_list_string(addr, NULL, 0); + if(save_personal) + addr->personal = save_personal; + + if((l = prefix ? strlen(prefix) : 0) != 0) + strncpy(s, prefix, width+1); + + iutf8ncpy(s + l, a_string, width - l); + s[width] = '\0'; + + fs_give((void **)&a_string); + + return(TRUE); + } + + if(save_personal) + addr->personal = save_personal; + + return(FALSE); +} + + +void +index_data_env(INDEXDATA_S *idata, ENVELOPE *env) +{ + if(!env){ + idata->bogus = 2; + return; + } + + idata->from = env->from; + idata->to = env->to; + idata->cc = env->cc; + idata->sender = env->sender; + idata->subject = env->subject; + idata->date = (char *) env->date; + idata->newsgroups = env->newsgroups; + + idata->valid_to = 1; /* signal that everythings here */ + idata->valid_cc = 1; + idata->valid_sender = 1; + idata->valid_news = 1; +} + + +/* + * Put a string representing the date into str. The source date is + * in the string datesrc. The format to be used is in type. + * Notice that type is an IndexColType, but really only a subset of + * IndexColType types are allowed. + * + * Args datesrc -- The source date string + * type -- What type of output we want + * v -- If set, variable width output is ok. (Oct 9 not Oct 9) + * str -- Put the answer here. + * str_len -- Length of str + * monabb_width -- This is a hack to get dates to line up right. For + * example, in French (but without accents here) + * dec. 21 + * fevr. 23 + * mars 7 + * For this monabb_width would be 5. + */ +void +date_str(char *datesrc, IndexColType type, int v, char *str, size_t str_len, + int monabb_width) +{ + char year4[5], /* 4 digit year */ + yearzero[3], /* zero padded, 2-digit year */ + monzero[3], /* zero padded, 2-digit month */ + mon[3], /* 1 or 2-digit month, no pad */ + dayzero[3], /* zero padded, 2-digit day */ + day[3], /* 1 or 2-digit day, no pad */ + dayord[3], /* 2-letter ordinal label */ + monabb[10], /* 3-letter month abbrev */ + /* actually maybe not 3 if localized */ + hour24[3], /* 2-digit, 24 hour clock hour */ + hour12[3], /* 12 hour clock hour, no pad */ + minzero[3], /* zero padded, 2-digit minutes */ + timezone[6]; /* timezone, like -0800 or +... */ + int hr12; + int curtype, lastmonthtype, lastyeartype, preftype; + int sdatetimetype, sdatetime24type; + struct date d; +#define TODAYSTR N_("Today") + + curtype = (type == iCurDate || + type == iCurDateIso || + type == iCurDateIsoS || + type == iCurPrefDate || + type == iCurPrefDateTime || + type == iCurPrefTime || + type == iCurTime24 || + type == iCurTime12 || + type == iCurDay || + type == iCurDay2Digit || + type == iCurDayOfWeek || + type == iCurDayOfWeekAbb || + type == iCurMon || + type == iCurMon2Digit || + type == iCurMonLong || + type == iCurMonAbb || + type == iCurYear || + type == iCurYear2Digit); + lastmonthtype = (type == iLstMon || + type == iLstMon2Digit || + type == iLstMonLong || + type == iLstMonAbb || + type == iLstMonYear || + type == iLstMonYear2Digit); + lastyeartype = (type == iLstYear || + type == iLstYear2Digit); + sdatetimetype = (type == iSDateTime || + type == iSDateTimeIso || + type == iSDateTimeIsoS || + type == iSDateTimeS1 || + type == iSDateTimeS2 || + type == iSDateTimeS3 || + type == iSDateTimeS4 || + type == iSDateTime24 || + type == iSDateTimeIso24 || + type == iSDateTimeIsoS24 || + type == iSDateTimeS124 || + type == iSDateTimeS224 || + type == iSDateTimeS324 || + type == iSDateTimeS424); + sdatetime24type = (type == iSDateTime24 || + type == iSDateTimeIso24 || + type == iSDateTimeIsoS24 || + type == iSDateTimeS124 || + type == iSDateTimeS224 || + type == iSDateTimeS324 || + type == iSDateTimeS424); + preftype = (type == iPrefDate || + type == iPrefDateTime || + type == iPrefTime || + type == iCurPrefDate || + type == iCurPrefDateTime || + type == iCurPrefTime); + if(str_len > 0) + str[0] = '\0'; + + if(!(datesrc && datesrc[0]) && !(curtype || lastmonthtype || lastyeartype)) + return; + + if(curtype || lastmonthtype || lastyeartype){ + char dbuf[200]; + + rfc822_date(dbuf); + parse_date(dbuf, &d); + + if(lastyeartype) + d.year--; + else if(lastmonthtype){ + d.month--; + if(d.month <= 0){ + d.month = 12; + d.year--; + } + } + } + else{ + parse_date(F_ON(F_DATES_TO_LOCAL,ps_global) + ? convert_date_to_local(datesrc) : datesrc, &d); + if(d.year == -1 || d.month == -1 || d.day == -1){ + sdatetimetype = 0; + sdatetime24type = 0; + preftype = 0; + switch(type){ + case iSDate: case iSDateTime: case iSDateTime24: + type = iS1Date; + break; + + case iSDateIso: case iSDateTimeIso: case iSDateTimeIso24: + case iPrefDate: case iPrefTime: case iPrefDateTime: + type = iDateIso; + break; + + case iSDateIsoS: case iSDateTimeIsoS: case iSDateTimeIsoS24: + type = iDateIsoS; + break; + + case iSDateS1: case iSDateTimeS1: case iSDateTimeS124: + type = iS1Date; + break; + + case iSDateS2: case iSDateTimeS2: case iSDateTimeS224: + type = iS1Date; + break; + + case iSDateS3: case iSDateTimeS3: case iSDateTimeS324: + type = iS1Date; + break; + + case iSDateS4: case iSDateTimeS4: case iSDateTimeS424: + type = iS1Date; + break; + + default: + break; + } + } + } + + /* some special ones to start with */ + if(preftype){ + struct tm tm, *tmptr = NULL; + time_t now; + + /* + * Make sure we get the right one if we're using current time. + */ + if(curtype){ + now = time((time_t *) 0); + if(now != (time_t) -1) + tmptr = localtime(&now); + } + + if(!tmptr){ + memset(&tm, 0, sizeof(tm)); + tm.tm_year = MIN(MAX(d.year-1900, 0), 2000); + tm.tm_mon = MIN(MAX(d.month-1, 0), 11); + tm.tm_mday = MIN(MAX(d.day, 1), 31); + tm.tm_hour = MIN(MAX(d.hour, 0), 23); + tm.tm_min = MIN(MAX(d.minute, 0), 59); + tm.tm_wday = MIN(MAX(d.wkday, 0), 6); + tmptr = &tm; + } + + switch(type){ + case iPrefDate: + case iCurPrefDate: + our_strftime(str, str_len, "%x", tmptr); + break; + case iPrefTime: + case iCurPrefTime: + our_strftime(str, str_len, "%X", tmptr); + break; + case iPrefDateTime: + case iCurPrefDateTime: + our_strftime(str, str_len, "%c", tmptr); + break; + default: + assert(0); + break; + } + + return; + } + + strncpy(monabb, (d.month > 0 && d.month < 13) + ? month_abbrev_locale(d.month) : "", sizeof(monabb)); + monabb[sizeof(monabb)-1] = '\0'; + + strncpy(mon, (d.month > 0 && d.month < 13) + ? int2string(d.month) : "", sizeof(mon)); + mon[sizeof(mon)-1] = '\0'; + + strncpy(day, (d.day > 0 && d.day < 32) + ? int2string(d.day) : "", sizeof(day)); + day[sizeof(day)-1] = '\0'; + + strncpy(dayord, + (d.day <= 0 || d.day > 31) ? "" : + (d.day == 1 || d.day == 21 || d.day == 31) ? "st" : + (d.day == 2 || d.day == 22 ) ? "nd" : + (d.day == 3 || d.day == 23 ) ? "rd" : "th", sizeof(dayord)); + + dayord[sizeof(dayord)-1] = '\0'; + + strncpy(year4, (d.year >= 1000 && d.year < 10000) + ? int2string(d.year) : "????", sizeof(year4)); + year4[sizeof(year4)-1] = '\0'; + + if(d.year >= 0){ + if((d.year % 100) < 10){ + yearzero[0] = '0'; + strncpy(yearzero+1, int2string(d.year % 100), sizeof(yearzero)-1); + } + else + strncpy(yearzero, int2string(d.year % 100), sizeof(yearzero)); + } + else + strncpy(yearzero, "??", sizeof(yearzero)); + + yearzero[sizeof(yearzero)-1] = '\0'; + + if(d.month > 0 && d.month < 10){ + monzero[0] = '0'; + strncpy(monzero+1, int2string(d.month), sizeof(monzero)-1); + } + else if(d.month >= 10 && d.month <= 12) + strncpy(monzero, int2string(d.month), sizeof(monzero)); + else + strncpy(monzero, "??", sizeof(monzero)); + + monzero[sizeof(monzero)-1] = '\0'; + + if(d.day > 0 && d.day < 10){ + dayzero[0] = '0'; + strncpy(dayzero+1, int2string(d.day), sizeof(dayzero)-1); + } + else if(d.day >= 10 && d.day <= 31) + strncpy(dayzero, int2string(d.day), sizeof(dayzero)); + else + strncpy(dayzero, "??", sizeof(dayzero)); + + dayzero[sizeof(dayzero)-1] = '\0'; + + hr12 = (d.hour == 0) ? 12 : + (d.hour > 12) ? (d.hour - 12) : d.hour; + hour12[0] = '\0'; + if(hr12 > 0 && hr12 <= 12) + strncpy(hour12, int2string(hr12), sizeof(hour12)); + + hour12[sizeof(hour12)-1] = '\0'; + + hour24[0] = '\0'; + if(d.hour >= 0 && d.hour < 10){ + hour24[0] = '0'; + strncpy(hour24+1, int2string(d.hour), sizeof(hour24)-1); + } + else if(d.hour >= 10 && d.hour < 24) + strncpy(hour24, int2string(d.hour), sizeof(hour24)); + + hour24[sizeof(hour24)-1] = '\0'; + + minzero[0] = '\0'; + if(d.minute >= 0 && d.minute < 10){ + minzero[0] = '0'; + strncpy(minzero+1, int2string(d.minute), sizeof(minzero)-1); + } + else if(d.minute >= 10 && d.minute <= 60) + strncpy(minzero, int2string(d.minute), sizeof(minzero)); + + minzero[sizeof(minzero)-1] = '\0'; + + if(sizeof(timezone) > 5){ + if(d.hours_off_gmt <= 0){ + timezone[0] = '-'; + d.hours_off_gmt *= -1; + d.min_off_gmt *= -1; + } + else + timezone[0] = '+'; + + timezone[1] = '\0'; + if(d.hours_off_gmt >= 0 && d.hours_off_gmt < 10){ + timezone[1] = '0'; + strncpy(timezone+2, int2string(d.hours_off_gmt), sizeof(timezone)-2); + } + else if(d.hours_off_gmt >= 10 && d.hours_off_gmt < 24) + strncpy(timezone+1, int2string(d.hours_off_gmt), sizeof(timezone)-1); + else{ + timezone[1] = '0'; + timezone[2] = '0'; + } + + timezone[3] = '\0'; + if(d.min_off_gmt >= 0 && d.min_off_gmt < 10){ + timezone[3] = '0'; + strncpy(timezone+4, int2string(d.min_off_gmt), sizeof(timezone)-4); + } + else if(d.min_off_gmt >= 10 && d.min_off_gmt <= 60) + strncpy(timezone+3, int2string(d.min_off_gmt), sizeof(timezone)-3); + else{ + timezone[3] = '0'; + timezone[4] = '0'; + } + + timezone[5] = '\0'; + timezone[sizeof(timezone)-1] = '\0'; + } + + switch(type){ + case iRDate: + /* this one is not locale-specific */ + snprintf(str, str_len, "%s%s%s %s %s", + (d.wkday != -1) ? day_abbrev(d.wkday) : "", + (d.wkday != -1) ? ", " : "", + day, + (d.month > 0 && d.month < 13) ? month_abbrev(d.month) : "", + year4); + break; + case iDayOfWeekAbb: + case iCurDayOfWeekAbb: + strncpy(str, (d.wkday >= 0 && d.wkday <= 6) ? day_abbrev_locale(d.wkday) : "", str_len); + str[str_len-1] = '\0'; + break; + case iDayOfWeek: + case iCurDayOfWeek: + strncpy(str, (d.wkday >= 0 && d.wkday <= 6) ? day_name_locale(d.wkday) : "", str_len); + str[str_len-1] = '\0'; + break; + case iYear: + case iCurYear: + case iLstYear: + case iLstMonYear: + strncpy(str, year4, str_len); + break; + case iDay2Digit: + case iCurDay2Digit: + strncpy(str, dayzero, str_len); + break; + case iMon2Digit: + case iCurMon2Digit: + case iLstMon2Digit: + strncpy(str, monzero, str_len); + break; + case iYear2Digit: + case iCurYear2Digit: + case iLstYear2Digit: + case iLstMonYear2Digit: + strncpy(str, yearzero, str_len); + break; + case iTimezone: + strncpy(str, timezone, str_len); + break; + case iDay: + case iCurDay: + strncpy(str, day, str_len); + break; + case iDayOrdinal: + snprintf(str, str_len, "%s%s", day, dayord); + break; + case iMon: + case iCurMon: + case iLstMon: + if(d.month > 0 && d.month <= 12) + strncpy(str, int2string(d.month), str_len); + + break; + case iMonAbb: + case iCurMonAbb: + case iLstMonAbb: + strncpy(str, monabb, str_len); + break; + case iMonLong: + case iCurMonLong: + case iLstMonLong: + strncpy(str, (d.month > 0 && d.month < 13) + ? month_name_locale(d.month) : "", str_len); + break; + case iDate: + case iCurDate: + if(v) + snprintf(str, str_len, "%s%s%s", monabb, (monabb[0] && day[0]) ? " " : "", day); + else{ + if(monabb_width > 0) + utf8_snprintf(str, str_len, "%-*.*w %2s", + monabb_width, monabb_width, monabb, day); + else + snprintf(str, str_len, "%s %2s", monabb, day); + } + + break; + case iLDate: + if(v) + snprintf(str, str_len, "%s%s%s%s%s", monabb, + (monabb[0] && day[0]) ? " " : "", day, + ((monabb[0] || day[0]) && year4[0]) ? ", " : "", + year4); + else{ + if(monabb_width > 0) + utf8_snprintf(str, str_len, "%-*.*w %2s%c %4s", + monabb_width, monabb_width, + monabb, day, + (monabb[0] && day[0] && year4[0]) ? ',' : ' ', year4); + else + snprintf(str, str_len, "%s %2s%c %4s", monabb, day, + (monabb[0] && day[0] && year4[0]) ? ',' : ' ', + year4); + } + + break; + case iS1Date: + case iS2Date: + case iS3Date: + case iS4Date: + case iDateIso: + case iDateIsoS: + case iCurDateIso: + case iCurDateIsoS: + if(monzero[0] == '?' && dayzero[0] == '?' && + yearzero[0] == '?') + snprintf(str, str_len, "%8s", ""); + else{ + switch(type){ + case iS1Date: + snprintf(str, str_len, "%2s/%2s/%2s", + monzero, dayzero, yearzero); + break; + case iS2Date: + snprintf(str, str_len, "%2s/%2s/%2s", + dayzero, monzero, yearzero); + break; + case iS3Date: + snprintf(str, str_len, "%2s.%2s.%2s", + dayzero, monzero, yearzero); + break; + case iS4Date: + snprintf(str, str_len, "%2s.%2s.%2s", + yearzero, monzero, dayzero); + break; + case iDateIsoS: + case iCurDateIsoS: + snprintf(str, str_len, "%2s-%2s-%2s", + yearzero, monzero, dayzero); + break; + case iDateIso: + case iCurDateIso: + snprintf(str, str_len, "%4s-%2s-%2s", + year4, monzero, dayzero); + break; + default: + break; + } + } + + break; + case iTime24: + case iCurTime24: + snprintf(str, str_len, "%2s%c%2s", + (hour24[0] && minzero[0]) ? hour24 : "", + (hour24[0] && minzero[0]) ? ':' : ' ', + (hour24[0] && minzero[0]) ? minzero : ""); + break; + case iTime12: + case iCurTime12: + snprintf(str, str_len, "%s%c%2s%s", + (hour12[0] && minzero[0]) ? hour12 : "", + (hour12[0] && minzero[0]) ? ':' : ' ', + (hour12[0] && minzero[0]) ? minzero : "", + (hour12[0] && minzero[0] && d.hour < 12) ? "am" : + (hour12[0] && minzero[0] && d.hour >= 12) ? "pm" : + " "); + break; + case iSDate: case iSDateIso: case iSDateIsoS: + case iSDateS1: case iSDateS2: case iSDateS3: case iSDateS4: + case iSDateTime: case iSDateTimeIso: case iSDateTimeIsoS: + case iSDateTimeS1: case iSDateTimeS2: case iSDateTimeS3: case iSDateTimeS4: + case iSDateTime24: case iSDateTimeIso24: case iSDateTimeIsoS24: + case iSDateTimeS124: case iSDateTimeS224: case iSDateTimeS324: case iSDateTimeS424: + { struct date now, last_day; + char dbuf[200]; + int msg_day_of_year, now_day_of_year, today; + int diff, ydiff, last_day_of_year; + + rfc822_date(dbuf); + parse_date(dbuf, &now); + today = day_of_week(&now) + 7; + + if(today >= 0+7 && today <= 6+7){ + now_day_of_year = day_of_year(&now); + msg_day_of_year = day_of_year(&d); + ydiff = now.year - d.year; + + if(msg_day_of_year == -1) + diff = -100; + else if(ydiff == 0) + diff = now_day_of_year - msg_day_of_year; + else if(ydiff == 1){ + last_day = d; + last_day.month = 12; + last_day.day = 31; + last_day_of_year = day_of_year(&last_day); + + diff = now_day_of_year + + (last_day_of_year - msg_day_of_year); + } + else if(ydiff == -1){ + last_day = now; + last_day.month = 12; + last_day.day = 31; + last_day_of_year = day_of_year(&last_day); + + diff = -1 * (msg_day_of_year + + (last_day_of_year - now_day_of_year)); + } + else if(ydiff > 1) + diff = 100; + else + diff = -100; + + if(diff == 0) + strncpy(str, _(TODAYSTR), str_len); + else if(diff == 1) + strncpy(str, _("Yesterday"), str_len); + else if(diff > 1 && diff < 7) + snprintf(str, str_len, "%s", day_name_locale((today - diff) % 7)); + else if(diff == -1) + strncpy(str, _("Tomorrow"), str_len); + else if(diff < -1 && diff > -7) + snprintf(str, str_len, _("Next %.3s!"), + day_name_locale((today - diff) % 7)); + else if(diff > 0 + && (ydiff == 0 + || (ydiff == 1 && 12 + now.month - d.month < 6))){ + if(v) + snprintf(str, str_len, "%s%s%s", monabb, + (monabb[0] && day[0]) ? " " : "", day); + else{ + if(monabb_width > 0) + utf8_snprintf(str, str_len, "%-*.*w %2s", + monabb_width, monabb_width, monabb, day); + else + snprintf(str, str_len, "%s %2s", monabb, day); + } + } + else{ + if(msg_day_of_year == -1 && (type == iSDate || type == iSDateTime)) + type = iSDateTimeIsoS; + + switch(type){ + case iSDate: case iSDateTime: case iSDateTime24: + { + struct tm tm; + + memset(&tm, 0, sizeof(tm)); + tm.tm_year = MIN(MAX(d.year-1900, 0), 2000); + tm.tm_mon = MIN(MAX(d.month-1, 0), 11); + tm.tm_mday = MIN(MAX(d.day, 1), 31); + tm.tm_hour = MIN(MAX(d.hour, 0), 23); + tm.tm_min = MIN(MAX(d.minute, 0), 59); + our_strftime(str, str_len, "%x", &tm); + } + + break; + case iSDateS1: case iSDateTimeS1: case iSDateTimeS124: + if(v) + snprintf(str, str_len, "%s/%s/%s%s", mon, day, yearzero, + diff < 0 ? "!" : ""); + else + snprintf(str, str_len, "%s%s/%s/%s%s", + (mon[0] && mon[1]) ? "" : " ", + mon, dayzero, yearzero, + diff < 0 ? "!" : ""); + break; + case iSDateS2: case iSDateTimeS2: case iSDateTimeS224: + if(v) + snprintf(str, str_len, "%s/%s/%s%s", day, mon, yearzero, + diff < 0 ? "!" : ""); + else + snprintf(str, str_len, "%s%s/%s/%s%s", + (day[0] && day[1]) ? "" : " ", + day, monzero, yearzero, + diff < 0 ? "!" : ""); + break; + case iSDateS3: case iSDateTimeS3: case iSDateTimeS324: + if(v) + snprintf(str, str_len, "%s.%s.%s%s", day, mon, yearzero, + diff < 0 ? "!" : ""); + else + snprintf(str, str_len, "%s%s.%s.%s%s", + (day[0] && day[1]) ? "" : " ", + day, monzero, yearzero, + diff < 0 ? "!" : ""); + break; + case iSDateS4: case iSDateTimeS4: case iSDateTimeS424: + if(v) + snprintf(str, str_len, "%s.%s.%s%s", + yearzero, monzero, dayzero, + diff < 0 ? "!" : ""); + else + snprintf(str, str_len, "%s.%s.%s%s", + yearzero, monzero, dayzero, + diff < 0 ? "!" : ""); + break; + case iSDateIsoS: case iSDateTimeIsoS: case iSDateTimeIsoS24: + snprintf(str, str_len, "%2s-%2s-%2s", + yearzero, monzero, dayzero); + break; + case iSDateIso: case iSDateTimeIso: case iSDateTimeIso24: + snprintf(str, str_len, "%4s-%2s-%2s", + year4, monzero, dayzero); + break; + default: + break; + } + } + + } + else{ + if(v) + snprintf(str, str_len, "%s%s%s", monabb, + (monabb[0] && day[0]) ? " " : "", day); + else{ + if(monabb_width > 0) + utf8_snprintf(str, str_len, "%-*.*w %2s", + monabb_width, monabb_width, monabb, day); + else + snprintf(str, str_len, "%s %2s", monabb, day); + } + } + } + + break; + + default: + break; + } + + str[str_len-1] = '\0'; + + if(type == iSTime || + (sdatetimetype && !strcmp(str, _(TODAYSTR)))){ + struct date now, last_day; + char dbuf[200], *Ddd, *ampm; + int daydiff; + + str[0] = '\0'; + rfc822_date(dbuf); + parse_date(dbuf, &now); + + /* Figure out if message date lands in the past week */ + + /* (if message dated this month or last month...) */ + if((d.year == now.year && d.month >= now.month - 1) || + (d.year == now.year - 1 && d.month == 12 && now.month == 1)){ + + daydiff = day_of_year(&now) - day_of_year(&d); + + /* + * If msg in end of last year (and we're in first bit of "this" + * year), diff will be backwards; fix up by adding number of days + * in last year (usually 365, but occasionally 366)... + */ + if(d.year == now.year - 1){ + last_day = d; + last_day.month = 12; + last_day.day = 31; + + daydiff += day_of_year(&last_day); + } + } + else + daydiff = -100; /* comfortably out of range (of past week) */ + + /* Build 2-digit hour and am/pm indicator, used below */ + + if(d.hour >= 0 && d.hour < 24){ + snprintf(hour12, sizeof(hour12), "%02d", (d.hour % 12 == 0) ? 12 : d.hour % 12); + ampm = (d.hour < 12) ? "am" : "pm"; + snprintf(hour24, sizeof(hour24), "%02d", d.hour); + } + else{ + strncpy(hour12, "??", sizeof(hour12)); + hour12[sizeof(hour12)-1] = '\0'; + ampm = "__"; + strncpy(hour24, "??", sizeof(hour24)); + hour24[sizeof(hour24)-1] = '\0'; + } + + /* Build date/time in str, in format similar to that used by w(1) */ + + if(daydiff == 0){ /* If date is today, "HH:MMap" */ + if(d.minute >= 0 && d.minute < 60) + snprintf(minzero, sizeof(minzero), "%02d", d.minute); + else{ + strncpy(minzero, "??", sizeof(minzero)); + minzero[sizeof(minzero)-1] = '\0'; + } + + snprintf(str, str_len, "%s:%s%s", sdatetime24type ? hour24 : hour12, + minzero, sdatetime24type ? "" : ampm); + } + else if(daydiff >= 1 && daydiff < 6){ /* If <1wk ago, "DddHHap" */ + + if(d.month >= 1 && d.day >= 1 && d.year >= 0 && + d.month <= 12 && d.day <= 31 && d.year <= 9999) + Ddd = day_abbrev_locale(day_of_week(&d)); + else + Ddd = "???"; + + snprintf(str, str_len, "%s%s%s", Ddd, hour12, ampm); + } + else{ /* date is old or future, "ddMmmyy" */ + strncpy(monabb, (d.month >= 1 && d.month <= 12) + ? month_abbrev_locale(d.month) : "???", sizeof(monabb)); + monabb[sizeof(monabb)-1] = '\0'; + + if(d.day >= 1 && d.day <= 31) + snprintf(dayzero, sizeof(dayzero), "%02d", d.day); + else{ + strncpy(dayzero, "??", sizeof(dayzero)); + dayzero[sizeof(dayzero)-1] = '\0'; + } + + if(d.year >= 0 && d.year <= 9999) + snprintf(yearzero, sizeof(yearzero), "%02d", d.year % 100); + else{ + strncpy(yearzero, "??", sizeof(yearzero)); + yearzero[sizeof(yearzero)-1] = '\0'; + } + + snprintf(str, str_len, "%s%s%s", dayzero, monabb, yearzero); + } + + if(str[0] == '0'){ /* leading 0 (date|hour) elided or blanked */ + if(v) + memmove(str, str + 1, strlen(str)); + else + str[0] = ' '; + } + } +} + + +/* + * Format a string representing the keywords into ice. + * + * This needs to be done in UTF-8, which may be tricky since it isn't labelled. + * + * Args idata -- which message? + * kwtype -- keywords or kw initials + * ice -- index cache entry for message + */ +void +key_str(INDEXDATA_S *idata, SubjKW kwtype, ICE_S *ice) +{ + int firstone = 1; + KEYWORD_S *kw; + char *word; + COLOR_PAIR *color = NULL; + SPEC_COLOR_S *sc = ps_global->kw_colors; + IELEM_S *ielem = NULL; + IFIELD_S *ourifield = NULL; + + if(ice && ice->ifield){ + /* move to last ifield, the one we're working */ + for(ourifield = ice->ifield; + ourifield && ourifield->next; + ourifield = ourifield->next) + ; + } + + if(!ourifield) + return; + + if(kwtype == KWInit){ + for(kw = ps_global->keywords; kw; kw = kw->next){ + if(user_flag_is_set(idata->stream, idata->rawno, kw->kw)){ + word = (kw->nick && kw->nick[0]) ? kw->nick : + (kw->kw && kw->kw[0]) ? kw->kw : ""; + + /* + * Pick off the first initial. Since word is UTF-8 it may + * take more than one byte for the first initial. + */ + + if(word && word[0]){ + UCS ucs; + unsigned long remaining_octets; + unsigned char *inputp; + + remaining_octets = strlen(word); + inputp = (unsigned char *) word; + ucs = (UCS) utf8_get(&inputp, &remaining_octets); + if(!(ucs & U8G_ERROR || ucs == UBOGON)){ + ielem = new_ielem(&ourifield->ielem); + ielem->freedata = 1; + ielem->datalen = (unsigned) (inputp - (unsigned char *) word); + ielem->data = (char *) fs_get((ielem->datalen + 1) * sizeof(char)); + strncpy(ielem->data, word, ielem->datalen); + ielem->data[ielem->datalen] = '\0'; + + if(pico_usingcolor() + && ((kw->nick && kw->nick[0] + && (color=hdr_color(kw->nick,NULL,sc))) + || (kw->kw && kw->kw[0] + && (color=hdr_color(kw->kw,NULL,sc))))){ + ielem->color = color; + color = NULL; + } + } + } + + if(color) + free_color_pair(&color); + } + } + } + else if(kwtype == KW){ + for(kw = ps_global->keywords; kw; kw = kw->next){ + if(user_flag_is_set(idata->stream, idata->rawno, kw->kw)){ + + if(!firstone){ + ielem = new_ielem(&ourifield->ielem); + ielem->freedata = 1; + ielem->data = cpystr(" "); + ielem->datalen = 1; + } + + firstone = 0; + + word = (kw->nick && kw->nick[0]) ? kw->nick : + (kw->kw && kw->kw[0]) ? kw->kw : ""; + + if(word[0]){ + ielem = new_ielem(&ourifield->ielem); + ielem->freedata = 1; + ielem->data = cpystr(word); + ielem->datalen = strlen(word); + + if(pico_usingcolor() + && ((kw->nick && kw->nick[0] + && (color=hdr_color(kw->nick,NULL,sc))) + || (kw->kw && kw->kw[0] + && (color=hdr_color(kw->kw,NULL,sc))))){ + ielem->color = color; + color = NULL; + } + } + + if(color) + free_color_pair(&color); + } + } + } + + /* + * If we're coloring some of the fields then add a dummy field + * at the end that can soak up the rest of the space after the last + * colored keyword. Otherwise, the last one's color will extend to + * the end of the field. + */ + if(pico_usingcolor()){ + ielem = new_ielem(&ourifield->ielem); + ielem->freedata = 1; + ielem->data = cpystr(" "); + ielem->datalen = 1; + } + + ourifield->leftadj = 1; + set_ielem_widths_in_field(ourifield); +} + + +void +prio_str(INDEXDATA_S *idata, IndexColType ctype, ICE_S *ice) +{ + IFIELD_S *ourifield = NULL; + IELEM_S *ielem = NULL; + char *hdrval; + PRIORITY_S *p; + int v; + + if(ice && ice->ifield){ + /* move to last ifield, the one we're working */ + for(ourifield = ice->ifield; + ourifield && ourifield->next; + ourifield = ourifield->next) + ; + } + + if(!ourifield) + return; + + hdrval = fetch_header(idata, PRIORITYNAME); + + if(hdrval && hdrval[0] && isdigit(hdrval[0])){ + v = atoi(hdrval); + if(v >= 1 && v <= 5 && v != 3){ + + ielem = new_ielem(&ourifield->ielem); + ielem->freedata = 1; + + switch(ctype){ + case iPrio: + ielem->data = (char *) fs_get(2 * sizeof(char)); + ielem->data[0] = hdrval[0]; + ielem->data[1] = '\0'; + break; + + case iPrioAlpha: + for(p = priorities; p && p->desc; p++) + if(p->val == v) + break; + + if(p && p->desc) + ielem->data = cpystr(p->desc); + + break; + + case iPrioBang: + ielem->data = (char *) fs_get(2 * sizeof(char)); + ielem->data[0] = '\0'; + switch(v){ + case 1: case 2: + ielem->data[0] = '!'; + break; + + case 4: case 5: + /* + * We could put a Unicode downarrow in here but + * we have no way of knowing if the user's font + * will have it (I think). + */ + ielem->data[0] = 'v'; + break; + } + + ielem->data[1] = '\0'; + + break; + + default: + panic("Unhandled case in prio_str"); + break; + } + + if(!ielem->data) + ielem->data = cpystr(""); + + if(ielem && ielem->data) + ielem->datalen = strlen(ielem->data); + + if((v == 1 || v == 2) && pico_usingcolor() + && ps_global->VAR_IND_HIPRI_FORE_COLOR + && ps_global->VAR_IND_HIPRI_BACK_COLOR){ + ielem->type = eTypeCol; + ielem->freecolor = 1; + ielem->color = new_color_pair(ps_global->VAR_IND_HIPRI_FORE_COLOR, ps_global->VAR_IND_HIPRI_BACK_COLOR); + } + else if((v == 4 || v == 5) && pico_usingcolor() + && ps_global->VAR_IND_LOPRI_FORE_COLOR + && ps_global->VAR_IND_LOPRI_BACK_COLOR){ + ielem->type = eTypeCol; + ielem->freecolor = 1; + ielem->color = new_color_pair(ps_global->VAR_IND_LOPRI_FORE_COLOR, ps_global->VAR_IND_LOPRI_BACK_COLOR); + } + + ourifield->leftadj = 1; + set_ielem_widths_in_field(ourifield); + } + + fs_give((void **) &hdrval); + } +} + + +void +header_str(INDEXDATA_S *idata, HEADER_TOK_S *hdrtok, ICE_S *ice) +{ + IFIELD_S *ourifield = NULL; + IELEM_S *ielem = NULL; + char *fieldval = NULL; + + if(ice && ice->ifield){ + /* move to last ifield, the one we're working */ + for(ourifield = ice->ifield; + ourifield && ourifield->next; + ourifield = ourifield->next) + ; + } + + if(!ourifield) + return; + + fieldval = get_fieldval(idata, hdrtok); + + if(fieldval){ + ielem = new_ielem(&ourifield->ielem); + ielem->freedata = 1; + ielem->data = fieldval; + ielem->datalen = strlen(fieldval); + fieldval = NULL; + ourifield->leftadj = (hdrtok->adjustment == Left) ? 1 : 0; + } + + set_ielem_widths_in_field(ourifield); +} + + +char * +get_fieldval(INDEXDATA_S *idata, HEADER_TOK_S *hdrtok) +{ + int sep, fieldnum; + char *hdrval = NULL, *testval; + char *fieldval = NULL, *firstval; + char *retfieldval = NULL; + + if(!hdrtok) + return(retfieldval); + + if(hdrtok && hdrtok->hdrname && hdrtok->hdrname[0]) + hdrval = fetch_header(idata, hdrtok ? hdrtok->hdrname : ""); + + /* find start of fieldnum'th field */ + fieldval = hdrval; + for(fieldnum = MAX(hdrtok->fieldnum-1, 0); + fieldnum > 0 && fieldval && *fieldval; fieldnum--){ + + firstval = NULL; + for(sep = 0; sep < hdrtok->fieldsepcnt; sep++){ + testval = hdrtok->fieldseps ? strchr(fieldval, hdrtok->fieldseps[sep]) : NULL; + if(testval && (!firstval || testval < firstval)) + firstval = testval; + } + + fieldval = firstval; + if(fieldval && *fieldval) + fieldval++; + } + + /* tie off end of field */ + if(fieldval && *fieldval && hdrtok->fieldnum > 0){ + firstval = NULL; + for(sep = 0; sep < hdrtok->fieldsepcnt; sep++){ + testval = hdrtok->fieldseps ? strchr(fieldval, hdrtok->fieldseps[sep]) : NULL; + if(testval && (!firstval || testval < firstval)) + firstval = testval; + } + + if(firstval) + *firstval = '\0'; + } + + if(!fieldval) + fieldval = ""; + + retfieldval = cpystr(fieldval); + + if(hdrval) + fs_give((void **) &hdrval); + + return(retfieldval); +} + + +long +scorevalfrommsg(MAILSTREAM *stream, MsgNo rawno, HEADER_TOK_S *hdrtok, int no_fetch) +{ + INDEXDATA_S idata; + MESSAGECACHE *mc; + char *fieldval = NULL; + long retval = 0L; + + memset(&idata, 0, sizeof(INDEXDATA_S)); + idata.stream = stream; + idata.no_fetch = no_fetch; + idata.msgno = mn_raw2m(sp_msgmap(stream), rawno); + idata.rawno = rawno; + if(stream && idata.rawno > 0L && idata.rawno <= stream->nmsgs + && (mc = mail_elt(stream, idata.rawno))){ + idata.size = mc->rfc822_size; + index_data_env(&idata, pine_mail_fetchenvelope(stream,idata.rawno)); + } + else + idata.bogus = 2; + + fieldval = get_fieldval(&idata, hdrtok); + + if(fieldval){ + retval = atol(fieldval); + fs_give((void **) &fieldval); + } + + return(retval); +} + + +/* + * Put a string representing the subject into str. Idata tells us which + * message we are referring to. + * + * This means we should ensure that all data ends up being UTF-8 data. + * That covers the data in ice ielems and str. + * + * Args idata -- which message? + * str -- destination buffer + * strsize -- size of str buffer + * kwtype -- prepend keywords or kw initials before the subject + * opening -- add first text from body of message if there's room + * ice -- index cache entry for message + */ +void +subj_str(INDEXDATA_S *idata, char *str, size_t strsize, SubjKW kwtype, int opening, ICE_S *ice) +{ + char *subject, *origsubj, *origstr, *rawsubj, *sptr = NULL; + char *p, *border, *q = NULL, *free_subj = NULL; + char *sp; + size_t len; + int width = -1; + int depth = 0, mult = 2; + int save; + int do_subj = 0, truncated_tree = 0; + PINETHRD_S *thd, *thdorig; + IELEM_S *ielem = NULL, *subjielem = NULL; + IFIELD_S *ourifield = NULL; + + if(strsize <= 0) + return; + + /* + * If we need the data at the start of the message and we're in + * a c-client callback, defer the data lookup until later. + */ + if(opening && idata->no_fetch){ + idata->bogus = 1; + return; + } + + if(ice && ice->ifield){ + /* move to last ifield, the one we're working on */ + for(ourifield = ice->ifield; + ourifield && ourifield->next; + ourifield = ourifield->next) + ; + } + + str[0] = str[strsize-1] = '\0'; + origstr = str; + rawsubj = fetch_subject(idata); + if(!rawsubj) + rawsubj = ""; + + /* + * Before we do anything else, decode the character set in the subject and + * work with the result. + */ + sp = (char *) rfc1522_decode_to_utf8((unsigned char *) tmp_20k_buf, + SIZEOF_20KBUF, rawsubj); + + len = strlen(sp); + len += 100; /* for possible charset, escaped characters */ + origsubj = fs_get((len+1) * sizeof(unsigned char)); + origsubj[0] = '\0'; + + iutf8ncpy(origsubj, sp, len); + + origsubj[len] = '\0'; + removing_trailing_white_space(origsubj); + + /* + * origsubj is the original subject but it has been decoded. We need + * to free it at the end of this routine. + */ + + + /* + * prepend_keyword will put the keyword stuff before the subject + * and split the subject up into its colored parts in subjielem. + * Subjielem is a local ielem which will have to be fit into the + * real ifield->ielem later. The print_format strings in subjielem will + * not be filled in by prepend_keyword because of the fact that we + * may have to adjust things for threading below. + * We use subjielem in case we want to insert some threading information + * at the front of the subject. + */ + if(kwtype == KW || kwtype == KWInit){ + subject = prepend_keyword_subject(idata->stream, idata->rawno, + origsubj, kwtype, + ourifield ? &subjielem : NULL, + ps_global->VAR_KW_BRACES); + free_subj = subject; + } + else{ + subject = origsubj; + if(ourifield){ + subjielem = new_ielem(&subjielem); + subjielem->type = eTypeCol; + subjielem->freedata = 1; + subjielem->data = cpystr(subject); + subjielem->datalen = strlen(subject); + if(pico_usingcolor() + && ps_global->VAR_IND_SUBJ_FORE_COLOR + && ps_global->VAR_IND_SUBJ_BACK_COLOR){ + subjielem->freecolor = 1; + subjielem->color = new_color_pair(ps_global->VAR_IND_SUBJ_FORE_COLOR, ps_global->VAR_IND_SUBJ_BACK_COLOR); + } + } + } + + /* + * This space is here so that if the subject does + * not extend all the way to the end of the field then + * we'll switch the color back and paint the rest of the + * field in the Normal color or the index line color. + */ + if(!opening){ + ielem = new_ielem(&subjielem); + ielem->freedata = 1; + ielem->data = cpystr(" "); + ielem->datalen = 1; + } + + if(!subject) + subject = ""; + + if(THREADING() + && (ps_global->thread_disp_style == THREAD_STRUCT + || ps_global->thread_disp_style == THREAD_MUTTLIKE + || ps_global->thread_disp_style == THREAD_INDENT_SUBJ1 + || ps_global->thread_disp_style == THREAD_INDENT_SUBJ2)){ + + /* + * Why do we want to truncate the subject and from strs? + * It's so we can put the [5] thread count things in below when + * we are threading and the thread structure runs off the right + * hand edge of the screen. This routine doesn't know that it + * is running off the edge unless it knows the actual width + * that we have to draw in. + */ + if(pith_opt_truncate_sfstr + && (*pith_opt_truncate_sfstr)() + && ourifield + && ourifield->width > 0) + width = ourifield->width; + + if(width < 0) + width = strsize-1; + + width = MIN(width, strsize-1); + + /* + * We're counting on the fact that this initial part of the + * string is ascii and we have one octet per character and + * characters are width 1 on the screen. + */ + border = str + width; + + thdorig = thd = fetch_thread(idata->stream, idata->rawno); + + if(pith_opt_condense_thread_cue) + width = (*pith_opt_condense_thread_cue)(thd, ice, &str, &strsize, width, + thd && thd->next + && get_lflag(idata->stream, + NULL,idata->rawno, + MN_COLL)); + + /* + * width is < available strsize and + * border points to something less than or equal + * to the end of the buffer. + */ + + sptr = str; + + if(thd) + while(thd->parent && + (thd = fetch_thread(idata->stream, thd->parent))) + depth++; + + if(depth > 0){ + if(ps_global->thread_disp_style == THREAD_INDENT_SUBJ1) + mult = 1; + + sptr += (mult*depth); + for(thd = thdorig, p = str + mult*depth - mult; + thd && thd->parent && p >= str; + thd = fetch_thread(idata->stream, thd->parent), p -= mult){ + if(p + mult >= border && !q){ + if(width >= 4 && depth < 100){ + snprintf(str, width+1, "%*s[%2d]", width-4, "", depth); + q = str + width-4; + } + else if(width >= 5 && depth < 1000){ + snprintf(str, width+1, "%*s[%3d]", width-5, "", depth); + q = str + width-5; + } + else{ + snprintf(str, width+1, "%s", repeat_char(width, '.')); + q = str; + } + + border = q; + truncated_tree++; + } + + if(p < border){ + p[0] = ' '; + if(p + 1 < border) + p[1] = ' '; + + if(ps_global->thread_disp_style == THREAD_STRUCT + || ps_global->thread_disp_style == THREAD_MUTTLIKE){ + /* + * WARNING! + * There is an unwarranted assumption here that VAR_THREAD_LASTREPLY_CHAR[0] + * is ascii. + */ + if(thd == thdorig && !thd->branch) + p[0] = ps_global->VAR_THREAD_LASTREPLY_CHAR[0]; + else if(thd == thdorig || thd->branch) + p[0] = '|'; + + if(p + 1 < border && thd == thdorig) + p[1] = '-'; + } + } + } + } + + if(sptr && !truncated_tree){ + /* + * Look to see if the subject is the same as the previous + * message in the thread, if any. If it is the same, don't + * reprint the subject. + * + * Note that when we're prepending keywords to the subject, + * and the user changes a keyword, we do invalidate + * the index cache for that message but we don't go to the + * trouble of invalidating the index cache for the the child + * of that node in the thread, so the MUTT subject line + * display for the child may be wrong. That is, it may show + * it is the same as this subject even though it no longer + * is, or vice versa. + */ + if(ps_global->thread_disp_style == THREAD_MUTTLIKE){ + if(depth == 0) + do_subj++; + else{ + if(thdorig->parent && + (thd = fetch_thread(idata->stream, thdorig->parent)) + && thd->rawno){ + char *this_orig = NULL, + *prev_orig = NULL, + *free_prev_orig = NULL, + *this_prep = NULL, /* includes prepend */ + *prev_prep = NULL; + ENVELOPE *env; + mailcache_t mc; + SORTCACHE *sc = NULL; + + /* get the stripped subject of previous message */ + mc = (mailcache_t) mail_parameters(NIL, GET_CACHE, NIL); + if(mc) + sc = (*mc)(idata->stream, thd->rawno, CH_SORTCACHE); + + if(sc && sc->subject) + prev_orig = sc->subject; + else{ + char *stripthis; + + env = pine_mail_fetchenvelope(idata->stream, + thd->rawno); + stripthis = (env && env->subject) + ? env->subject : ""; + + mail_strip_subject(stripthis, &prev_orig); + + free_prev_orig = prev_orig; + } + + mail_strip_subject(rawsubj, &this_orig); + + if(kwtype == KW || kwtype == KWInit){ + prev_prep = prepend_keyword_subject(idata->stream, + thd->rawno, + prev_orig, + kwtype, NULL, + ps_global->VAR_KW_BRACES); + + this_prep = prepend_keyword_subject(idata->stream, + idata->rawno, + this_orig, + kwtype, NULL, + ps_global->VAR_KW_BRACES); + + if((this_prep || prev_prep) + && ((this_prep && !prev_prep) + || (prev_prep && !this_prep) + || strucmp(this_prep, prev_prep))) + do_subj++; + } + else{ + if((this_orig || prev_orig) + && ((this_orig && !prev_orig) + || (prev_orig && !this_orig) + || strucmp(this_orig, prev_orig))) + do_subj++; + } + + /* + * If some of the thread is zoomed out of view, we + * want to display the subject of the first one that + * is in view. If any of the parents or grandparents + * etc of this message are visible, then we don't + * need to worry about it. If all of the parents have + * been zoomed away, then this is the first one. + * + * When you're looking at a particular case where + * some of the messages of a thread are selected it + * seems like we should look at not only our + * direct parents, but the siblings of the parent + * too. But that's not really correct, because those + * siblings are basically the starts of different + * branches, separate from our branch. They could + * have their own subjects, for example. This will + * give us cases where it looks like we are showing + * the subject too much, but it will be correct! + * + * In zoom_index() we clear_index_cache_ent for + * some lines which have subjects which might become + * visible when we zoom, and also in set_lflags + * where we might change subjects by unselecting + * something when zoomed. + */ + if(!do_subj){ + while(thd){ + if(!msgline_hidden(idata->stream, + sp_msgmap(idata->stream), + mn_raw2m(sp_msgmap(idata->stream), + (long) thd->rawno), + 0)){ + break; /* found a visible parent */ + } + + if(thd && thd->parent) + thd = fetch_thread(idata->stream,thd->parent); + else + thd = NULL; + } + + if(!thd) /* none were visible */ + do_subj++; + } + + if(this_orig) + fs_give((void **) &this_orig); + + if(this_prep) + fs_give((void **) &this_prep); + + if(free_prev_orig) + fs_give((void **) &free_prev_orig); + + if(prev_prep) + fs_give((void **) &prev_prep); + } + else + do_subj++; + } + } + else + do_subj++; + + if(do_subj){ + /* + * We don't need to worry about truncating to width + * here. If we go over the right hand edge it will be + * truncated. + */ + strsize -= (sptr - str); + + strncpy(sptr, subject, strsize-1); + sptr[strsize-1] = '\0'; + } + else if(ps_global->thread_disp_style == THREAD_MUTTLIKE){ + strsize -= (sptr - str); + + if(strsize > 0){ + sptr[0] = '>'; + sptr++; + } + + /* + * We decided we don't need the subject so we'd better + * eliminate subjielem. + */ + free_ielem(&subjielem); + } + } + else + free_ielem(&subjielem); /* no room for actual subject */ + + if(ourifield && sptr && sptr > origstr){ + ielem = new_ielem(&ourifield->ielem); + ielem->type = eThreadInfo; + ielem->freedata = 1; + save = *sptr; + *sptr = '\0'; + ielem->data = cpystr(origstr); + ielem->datalen = strlen(origstr); + *sptr = save; + } + } + else{ + /* + * Not much to do for the non-threading case. Just copy the + * subject we have so far into str and truncate it. + */ + strncpy(str, subject, strsize-1); + str[strsize-1] = '\0'; + } + + if(ourifield){ + /* + * We need to add subjielem to the end of the ourifield->ielem list. + */ + if(subjielem){ + if(ourifield->ielem){ + for(ielem = ourifield->ielem; + ielem && ielem->next; ielem = ielem->next) + ; + + ielem->next = subjielem; + } + else + ourifield->ielem = subjielem; + } + + ourifield->leftadj = 1; + } + + if(opening && ourifield){ + IELEM_S *ftielem = NULL; + size_t len; + char *first_text; + + first_text = fetch_firsttext(idata, 0); + + if(first_text){ + char sep[200]; + int seplen; + + strncpy(sep, ps_global->VAR_OPENING_SEP ? ps_global->VAR_OPENING_SEP : " - ", + sizeof(sep)); + sep[sizeof(sep)-1] = '\0'; + removing_double_quotes(sep); + seplen = strlen(sep); + + ftielem = new_ielem(&ftielem); + ftielem->type = eTypeCol; + ftielem->freedata = 1; + len = strlen(first_text) + seplen; + ftielem->data = (char *) fs_get((len + 1) * sizeof(char)); + + strncpy(ftielem->data, sep, seplen); + strncpy(ftielem->data+seplen, first_text, len+1-seplen); + ftielem->data[len] = '\0'; + + ftielem->datalen = strlen(ftielem->data); + if(first_text) + fs_give((void **) &first_text); + + if(ftielem){ + if(pico_usingcolor() + && ps_global->VAR_IND_OP_FORE_COLOR + && ps_global->VAR_IND_OP_BACK_COLOR){ + ftielem->freecolor = 1; + ftielem->color = new_color_pair(ps_global->VAR_IND_OP_FORE_COLOR, ps_global->VAR_IND_OP_BACK_COLOR); + + /* + * This space is here so that if the opening text does + * not extend all the way to the end of the field then + * we'll switch the color back and paint the rest of the + * field in the Normal color or the index line color. + */ + ielem = new_ielem(&ftielem); + ielem->freedata = 1; + ielem->data = cpystr(" "); + ielem->datalen = 1; + } + + if(ourifield->ielem){ + for(ielem = ourifield->ielem; + ielem && ielem->next; ielem = ielem->next) + ; + + ielem->next = ftielem; + } + else + ourifield->ielem = ftielem; + } + + ourifield->leftadj = 1; + } + } + + if(ourifield) + set_ielem_widths_in_field(ourifield); + + if(origsubj) + fs_give((void **) &origsubj); + + if(free_subj) + fs_give((void **) &free_subj); +} + + +/* + * Returns an allocated string which is the passed in subject with a + * list of keywords prepended. + * + * If kwtype == KW you will end up with + * + * {keyword1 keyword2} subject + * + * (actually, keyword nicknames will be used instead of the actual keywords + * in the case that the user defined nicknames) + * + * If kwtype == KWInit you get + * + * {AB} subject + * + * where A is the first letter of the first keyword and B is the first letter + * of the second defined keyword. No space between them. There could be more + * than two. + * + * If an ielemp is passed in it will be filled out with the data and colors + * of the pieces of the subject but the print_format strings will not + * be set. + */ +char * +prepend_keyword_subject(MAILSTREAM *stream, long int rawno, char *subject, + SubjKW kwtype, IELEM_S **ielemp, char *braces) +{ + char *p, *next_piece, *retsubj = NULL, *str; + char *left_brace = NULL, *right_brace = NULL; + size_t len; + int some_set = 0, save; + IELEM_S *ielem; + KEYWORD_S *kw; + COLOR_PAIR *color = NULL; + SPEC_COLOR_S *sc = ps_global->kw_colors; + + if(!subject) + subject = ""; + + if(braces && *braces) + get_pair(braces, &left_brace, &right_brace, 1, 0); + + len = (left_brace ? strlen(left_brace) : 0) + + (right_brace ? strlen(right_brace) : 0); + + if(stream && rawno >= 0L && rawno <= stream->nmsgs){ + for(kw = ps_global->keywords; kw; kw = kw->next) + if(user_flag_is_set(stream, rawno, kw->kw)){ + if(kwtype == KW){ + if(some_set) + len++; /* space between keywords */ + + str = kw->nick ? kw->nick : kw->kw ? kw->kw : ""; + len += strlen(str); + } + else if(kwtype == KWInit){ + str = kw->nick ? kw->nick : kw->kw ? kw->kw : ""; + /* interested in only the first UTF-8 initial */ + if(str && str[0]){ + UCS ucs; + unsigned long remaining_octets; + unsigned char *inputp; + + remaining_octets = strlen(str); + inputp = (unsigned char *) str; + ucs = (UCS) utf8_get(&inputp, &remaining_octets); + if(!(ucs & U8G_ERROR || ucs == UBOGON)){ + len += (unsigned) (inputp - (unsigned char *) str); + } + } + } + + some_set++; + } + } + + if((kwtype == KW || kwtype == KWInit) && some_set){ + len += strlen(subject); /* subject is already UTF-8 if needed */ + retsubj = (char *) fs_get((len + 1) * sizeof(*retsubj)); + memset(retsubj, 0, (len + 1) * sizeof(*retsubj)); + next_piece = p = retsubj; + + for(kw = ps_global->keywords; kw; kw = kw->next){ + if(user_flag_is_set(stream, rawno, kw->kw)){ + if(p == retsubj){ + if(left_brace && len > 0) + sstrncpy(&p, left_brace, len); + } + else if(kwtype == KW) + *p++ = ' '; + + if(ielemp && p > next_piece){ + save = *p; + *p = '\0'; + ielem = new_ielem(ielemp); + ielem->freedata = 1; + ielem->data = cpystr(next_piece); + ielem->datalen = strlen(next_piece); + *p = save; + next_piece = p; + } + + str = kw->nick ? kw->nick : kw->kw ? kw->kw : ""; + + if(kwtype == KWInit){ + if(str && str[0]){ + UCS ucs; + unsigned long remaining_octets; + unsigned char *inputp; + + remaining_octets = strlen(str); + inputp = (unsigned char *) str; + ucs = (UCS) utf8_get(&inputp, &remaining_octets); + if(!(ucs & U8G_ERROR || ucs == UBOGON)){ + if(len-(p-retsubj) > 0){ + sstrncpy(&p, str, MIN(inputp - (unsigned char *) str,len-(p-retsubj))); + if(p > next_piece && ielemp && pico_usingcolor() + && ((kw->nick && kw->nick[0] + && (color=hdr_color(kw->nick,NULL,sc))) + || (kw->kw && kw->kw[0] + && (color=hdr_color(kw->kw,NULL,sc))))){ + ielem = new_ielem(ielemp); + ielem->freedata = 1; + save = *p; + *p = '\0'; + ielem->data = cpystr(next_piece); + ielem->datalen = strlen(next_piece); + ielem->color = color; + color = NULL; + *p = save; + next_piece = p; + } + } + } + + if(color) + free_color_pair(&color); + } + } + else{ + if(len-(p-retsubj) > 0) + sstrncpy(&p, str, len-(p-retsubj)); + + if(p > next_piece && ielemp && pico_usingcolor() + && ((kw->nick && kw->nick[0] + && (color=hdr_color(kw->nick,NULL,sc))) + || (kw->kw && kw->kw[0] + && (color=hdr_color(kw->kw,NULL,sc))))){ + ielem = new_ielem(ielemp); + ielem->freedata = 1; + save = *p; + *p = '\0'; + ielem->data = cpystr(next_piece); + ielem->datalen = strlen(next_piece); + ielem->color = color; + color = NULL; + *p = save; + next_piece = p; + } + + if(color) + free_color_pair(&color); + } + } + } + + if(len-(p-retsubj) > 0 && right_brace) + sstrncpy(&p, right_brace, len-(p-retsubj)); + + if(ielemp && p > next_piece){ + save = *p; + *p = '\0'; + ielem = new_ielem(ielemp); + ielem->freedata = 1; + ielem->data = cpystr(next_piece); + ielem->datalen = strlen(next_piece); + *p = save; + next_piece = p; + } + + if(len-(p-retsubj) > 0 && subject) + sstrncpy(&p, subject, len-(p-retsubj)); + + if(ielemp && p > next_piece){ + save = *p; + *p = '\0'; + ielem = new_ielem(ielemp); + ielem->type = eTypeCol; + ielem->freedata = 1; + ielem->data = cpystr(next_piece); + ielem->datalen = strlen(next_piece); + *p = save; + next_piece = p; + if(pico_usingcolor() + && ps_global->VAR_IND_SUBJ_FORE_COLOR + && ps_global->VAR_IND_SUBJ_BACK_COLOR){ + ielem->freecolor = 1; + ielem->color = new_color_pair(ps_global->VAR_IND_SUBJ_FORE_COLOR, ps_global->VAR_IND_SUBJ_BACK_COLOR); + } + } + + retsubj[len] = '\0'; /* just making sure */ + } + else{ + if(ielemp){ + ielem = new_ielem(ielemp); + ielem->type = eTypeCol; + ielem->freedata = 1; + ielem->data = cpystr(subject); + ielem->datalen = strlen(subject); + if(pico_usingcolor() + && ps_global->VAR_IND_SUBJ_FORE_COLOR + && ps_global->VAR_IND_SUBJ_BACK_COLOR){ + ielem->freecolor = 1; + ielem->color = new_color_pair(ps_global->VAR_IND_SUBJ_FORE_COLOR, ps_global->VAR_IND_SUBJ_BACK_COLOR); + } + } + + retsubj = cpystr(subject); + } + + if(braces){ + if(left_brace) + fs_give((void **) &left_brace); + + if(right_brace) + fs_give((void **) &right_brace); + } + + return(retsubj); +} + + +/* + * This means we should ensure that all data ends up being UTF-8 data. + * That covers the data in ice ielems and str. + */ +void +from_str(IndexColType ctype, INDEXDATA_S *idata, char *str, size_t strsize, ICE_S *ice) +{ + char *field, *newsgroups, *border, *p, *fptr = NULL, *q = NULL; + ADDRESS *addr; + int width = -1; + int depth = 0, mult = 2; + PINETHRD_S *thd, *thdorig; + + if(THREADING() + && (ps_global->thread_disp_style == THREAD_INDENT_FROM1 + || ps_global->thread_disp_style == THREAD_INDENT_FROM2 + || ps_global->thread_disp_style == THREAD_STRUCT_FROM)){ + + if(pith_opt_truncate_sfstr && (*pith_opt_truncate_sfstr)()){ + IFIELD_S *ourifield = NULL; + + if(ice && ice->ifield){ + /* move to last ifield, the one we're working on */ + for(ourifield = ice->ifield; + ourifield && ourifield->next; + ourifield = ourifield->next) + ; + } + + if(ourifield && ourifield->width > 0) + width = ourifield->width; + } + + if(width < 0) + width = strsize-1; + + width = MIN(width, strsize-1); + + thdorig = thd = fetch_thread(idata->stream, idata->rawno); + border = str + width; + if(pith_opt_condense_thread_cue) + width = (*pith_opt_condense_thread_cue)(thd, ice, &str, &strsize, width, + thd && thd->next + && get_lflag(idata->stream, + NULL,idata->rawno, + MN_COLL)); + + fptr = str; + + if(thd) + while(thd->parent && (thd = fetch_thread(idata->stream, thd->parent))) + depth++; + + if(depth > 0){ + if(ps_global->thread_disp_style == THREAD_INDENT_FROM1) + mult = 1; + + fptr += (mult*depth); + for(thd = thdorig, p = str + mult*depth - mult; + thd && thd->parent && p >= str; + thd = fetch_thread(idata->stream, thd->parent), p -= mult){ + if(p + mult >= border && !q){ + if(width >= 4 && depth < 100){ + snprintf(str, width+1, "%*s[%2d]", width-4, "", depth); + q = str + width-4; + } + else if(width >= 5 && depth < 1000){ + snprintf(str, width+1, "%*s[%3d]", width-5, "", depth); + q = str + width-5; + } + else{ + snprintf(str, width+1, "%s", repeat_char(width, '.')); + q = str; + } + + border = q; + fptr = NULL; + } + + if(p + 1 < border){ + p[0] = p[1] = ' '; + if(ps_global->thread_disp_style == THREAD_STRUCT_FROM){ + /* + * WARNING! + * There is an unwarranted assumption here that VAR_THREAD_LASTREPLY_CHAR[0] + * is ascii. + */ + if(thd == thdorig && !thd->branch) + p[0] = ps_global->VAR_THREAD_LASTREPLY_CHAR[0]; + else if(thd == thdorig || thd->branch) + p[0] = '|'; + + if(thd == thdorig) + p[1] = '-'; + } + } + else if(p < border){ + p[0] = ' '; + if(ps_global->thread_disp_style == THREAD_STRUCT_FROM){ + /* + * WARNING! + * There is an unwarranted assumption here that VAR_THREAD_LASTREPLY_CHAR[0] + * is ascii. + */ + if(thd == thdorig && !thd->branch) + p[0] = ps_global->VAR_THREAD_LASTREPLY_CHAR[0]; + else if(thd == thdorig || thd->branch) + p[0] = '|'; + } + } + } + } + } + else + fptr = str; + + if(fptr){ + strsize -= (fptr - str); + switch(ctype){ + case iFromTo: + case iFromToNotNews: + if(!(addr = fetch_from(idata)) || address_is_us(addr, ps_global)){ + if(strsize-1 <= 4){ + strncpy(fptr, "To: ", strsize-1); + fptr[strsize-1] = '\0'; + break; + } + else{ + if((field = ((addr = fetch_to(idata)) + ? "To" + : (addr = fetch_cc(idata)) + ? "Cc" + : NULL)) + && set_index_addr(idata, field, addr, "To: ", + strsize-1, fptr)) + break; + + if(ctype == iFromTo && + (newsgroups = fetch_newsgroups(idata)) && + *newsgroups){ + snprintf(fptr, strsize, "To: %-*.*s", strsize-1-4, strsize-1-4, + newsgroups); + break; + } + + /* else fall thru to From: */ + } + } + /* else fall thru to From: */ + + if(idata->bogus) + break; + + case iFrom: + set_index_addr(idata, "From", fetch_from(idata), NULL, strsize-1, fptr); + break; + + case iAddress: + case iMailbox: + if((addr = fetch_from(idata)) && addr->mailbox && addr->mailbox[0]){ + char *mb = NULL, *hst = NULL, *at = NULL; + size_t len; + + mb = addr->mailbox; + if(ctype == iAddress && addr->host && addr->host[0] + && addr->host[0] != '.'){ + at = "@"; + hst = addr->host; + } + + len = strlen(mb); + if(!at || strsize-1 <= len) + snprintf(fptr, strsize, "%-*.*s", strsize-1, strsize-1, mb); + else + snprintf(fptr, strsize, "%s@%-*.*s", mb, strsize-1-len-1, strsize-1-len-1, hst); + } + + break; + + default: + break; + } + } +} + + +/* + * Set up the elements contained in field so that they take up the + * whole field width. Data is assumed to be UTF-8. + */ +void +set_ielem_widths_in_field(IFIELD_S *ifield) +{ + IELEM_S *ielem = NULL; + int datawidth, fmtwidth; + + if(!ifield) + return; + + fmtwidth = ifield->width; + + for(ielem = ifield->ielem; ielem && fmtwidth > 0; ielem = ielem->next){ + if(!ifield->leftadj && ielem->next){ + dprint((1, "set_ielem_widths_in_field(%d): right adjust with multiple elements, NOT SUPPOSED TO HAPPEN!\n", (int) ifield->ctype)); + assert(0); + } + + datawidth = (int) utf8_width(ielem->data); + if(datawidth >= fmtwidth || !ielem->next){ + set_print_format(ielem, fmtwidth, ifield->leftadj); + fmtwidth = 0; + } + else{ + set_print_format(ielem, datawidth, ifield->leftadj); + fmtwidth -= datawidth; + } + } +} + + +/* + * Simple hash function from K&R 2nd edition, p. 144. + * + * This one is modified to never return 0 so we can use that as a special + * value. Also, LINE_HASH_N fits in an unsigned long, so it too can be used + * as a special value that can't be returned by line_hash. + */ +unsigned long +line_hash(char *s) +{ + unsigned long hashval; + + for(hashval = 0; *s != '\0'; s++) + hashval = *s + 31 * hashval; + + hashval = hashval % LINE_HASH_N; + + if(!hashval) + hashval++; + + return(hashval); +} + + +/* + * Returns nonzero if considered hidden, 0 if not considered hidden. + */ +int +msgline_hidden(MAILSTREAM *stream, MSGNO_S *msgmap, long int msgno, int flags) +{ + int ret; + + if(flags & MH_ANYTHD){ + ret = ((any_lflagged(msgmap, MN_HIDE) > 0) + && get_lflag(stream, msgmap, msgno, MN_HIDE)); + } + else if(flags & MH_THISTHD && THREADING() && sp_viewing_a_thread(stream)){ + ret = (get_lflag(stream, msgmap, msgno, MN_HIDE) + || !get_lflag(stream, msgmap, msgno, MN_CHID2)); + } + else{ + if(THREADING() && sp_viewing_a_thread(stream)){ + ret = (get_lflag(stream, msgmap, msgno, MN_HIDE) + || !get_lflag(stream, msgmap, msgno, MN_CHID2) + || get_lflag(stream, msgmap, msgno, MN_CHID)); + } + else if(THRD_INDX()){ + /* + * If this message is in the collapsed part of a thread, + * it's hidden. It must be a top-level of a thread to be + * considered visible. Even if it is top-level, it is only + * visible if some message in the thread is not hidden. + */ + if(get_lflag(stream, msgmap, msgno, MN_CHID)) /* not top */ + ret = 1; + else{ + unsigned long rawno; + PINETHRD_S *thrd = NULL; + + rawno = mn_m2raw(msgmap, msgno); + if(rawno) + thrd = fetch_thread(stream, rawno); + + ret = !thread_has_some_visible(stream, thrd); + } + } + else{ + ret = ((any_lflagged(msgmap, MN_HIDE | MN_CHID) > 0) + && get_lflag(stream, msgmap, msgno, MN_HIDE | MN_CHID)); + } + } + + dprint((10, + "msgline_hidden(%ld): %s\n", msgno, ret ? "HID" : "VIS")); + + return(ret); +} + + +void +adjust_cur_to_visible(MAILSTREAM *stream, MSGNO_S *msgmap) +{ + long n, cur; + int dir; + + cur = mn_get_cur(msgmap); + + /* if current is hidden, adjust */ + if(cur >= 1L && cur <= mn_get_total(msgmap) + && msgline_hidden(stream, msgmap, cur, 0)){ + + dir = mn_get_revsort(msgmap) ? -1 : 1; + + for(n = cur; + ((dir == 1 && n >= 1L) || (dir == -1 && n <= mn_get_total(msgmap))) + && (n >= 1L && n <= mn_get_total(msgmap)) + && msgline_hidden(stream, msgmap, n, 0); + n -= dir) + ; + + if(((dir == 1 && n >= 1L) || (dir == -1 && n <= mn_get_total(msgmap))) + && (n >= 1L && n <= mn_get_total(msgmap))) + mn_reset_cur(msgmap, n); + else{ /* no visible in that direction */ + for(n = cur; + ((dir == 1 && n >= 1L) || (dir == -1 && n <= mn_get_total(msgmap))) + && (n >= 1L && n <= mn_get_total(msgmap)) + && msgline_hidden(stream, msgmap, n, 0); + n += dir) + ; + + if(((dir == 1 && n >= 1L) || (dir == -1 && n <= mn_get_total(msgmap))) + && (n >= 1L && n <= mn_get_total(msgmap))) + mn_reset_cur(msgmap, n); + /* else trouble! */ + } + } +} + + +void +setup_for_index_index_screen(void) +{ + format_index_line = format_index_index_line; + setup_header_widths = setup_index_header_widths; +} + + +void +setup_for_thread_index_screen(void) +{ + format_index_line = format_thread_index_line; + setup_header_widths = setup_thread_header_widths; +} + + +unsigned long +ice_hash(ICE_S *ice) +{ + char buf[MAX_SCREEN_COLS+1]; + + buf[0] = '\0'; + + if(ice) + simple_index_line(buf, sizeof(buf), ice, 0L); + + buf[sizeof(buf) - 1] = '\0'; + + return(line_hash(buf)); +} + + +char * +left_adjust(int width) +{ + return(format_str(width, 1)); +} + + +char * +right_adjust(int width) +{ + return(format_str(width, 0)); +} + + +/* + * Returns allocated and filled in format string. + */ +char * +format_str(int width, int left) +{ + char *format; + size_t len; + + len = PRINT_FORMAT_LEN(width,left) * sizeof(char); + format = (char *) fs_get(len + 1); + copy_format_str(width, left, format, len); + format[len] = '\0'; + + return(format); +} + + +/* + * Put the left or right adjusted format string of width width into + * dest. Dest is of size n+1. + */ +char * +copy_format_str(int width, int left, char *dest, int n) +{ + char *p; + + p = int2string(width); + + snprintf(dest, n+1, "%%%s%s.%ss", left ? "-" : "", p, p); + + dest[n] = '\0'; + + return(dest); +} + + +/* + * Sets up the print_format string to be width wide with left or right + * adjust. Takes care of memory freeing and allocation. + */ +void +set_print_format(IELEM_S *ielem, int width, int leftadj) +{ + if(ielem){ + ielem->wid = width; + + if(ielem->print_format){ + /* is there enough room? */ + if(ielem->freeprintf < PRINT_FORMAT_LEN(width,leftadj)+1){ + fs_resize((void **) &ielem->print_format, + (PRINT_FORMAT_LEN(width,leftadj)+1) * sizeof(char)); + ielem->freeprintf = (PRINT_FORMAT_LEN(width,leftadj) + 1) * sizeof(char); + } + + copy_format_str(width, leftadj, ielem->print_format, + PRINT_FORMAT_LEN(width,leftadj)); + } + else{ + ielem->print_format = leftadj ? left_adjust(width) + : right_adjust(width); + ielem->freeprintf = (PRINT_FORMAT_LEN(width,leftadj) + 1) * sizeof(char); + } + } +} |