/*----------------------------------------------------------------------
new_mail() - check for new mail in the inbox
Input: force -- flag indicating we should check for new mail no matter
time_for_check_point -- 0: GoodTime, 1: BadTime, 2: VeryBadTime
flags -- whether to q a new mail status message or defer the sort
Result: returns -1 if there was no new mail. Otherwise returns the
sorted message number of the smallest message number that
was changed. That is the screen needs to be repainted from
that message down.
Limit frequency of checks because checks use some resources. That is
they generate an IMAP packet or require locking the local mailbox.
(Acutally the lock isn't required, a stat will do, but the current
c-client mail code locks before it stats.)
Returns >= 0 only if there is a change in the given mail stream. Otherwise
this returns -1. On return the message counts in the pine
structure are updated to reflect the current number of messages including
any new mail and any expunging.
--- */
long
new_mail(int force_arg, CheckPointTime time_for_check_point, int flags)
{
static time_t last_check_point_call = 0;
long since_last_input;
time_t expunged_reaper_to, adj_idle_timeout, interval, adj;
static int nexttime = 0;
time_t now;
long n, rv = 0, t_nm_count = 0, exp_count;
MAILSTREAM *m;
int force, i, started_on;
int new_mail_was_announced = 0;
int have_pinged_non_special = 0;
int timeo;
dprint((9, "new mail called (force=%d %s flags=0x%x)\n",
force_arg,
time_for_check_point == GoodTime ? "GoodTime" :
time_for_check_point == BadTime ? "BadTime" :
time_for_check_point == VeryBadTime ? "VeryBad" :
time_for_check_point == DoItNow ? "DoItNow" : "?",
flags));
force = force_arg;
now = time(0);
timeo = get_input_timeout();
if(time_for_check_point == GoodTime)
adrbk_maintenance();
if(time_for_check_point == GoodTime || force_arg)
folder_unseen_count_updater(UFU_ANNOUNCE | (force_arg ? UFU_FORCE : 0));
if(sp_need_to_rethread(ps_global->mail_stream))
force = 1;
if(!force && sp_unsorted_newmail(ps_global->mail_stream))
force = !(flags & NM_DEFER_SORT);
if(!ps_global->mail_stream
|| !(timeo || force || sp_a_locked_stream_changed()))
return(-1);
last_check_point_call = now;
since_last_input = (long) now - (long) time_of_last_input();
/*
* We have this for loop followed by the do-while so that we will prefer
* to ping the active streams before we ping the inactive ones, in cases
* where the pings or checks are taking a long time.
*/
for(i = 0; i < ps_global->s_pool.nstream; i++){
m = ps_global->s_pool.streams[i];
if(!m || m->halfopen ||
(m != ps_global->mail_stream &&
!(force_arg && sp_flagged(m, SP_LOCKED))))
continue;
/*
* This for() loop is only the current folder, unless the user
* has forced the check, in which case it is all locked folders.
*/
/*
* After some amount of inactivity on a stream, the server may
* close the stream. Each protocol has its own idea of how much
* inactivity should be allowed before the stream is closed. For
* example, IMAP specifies that the server should not close the
* stream unilaterally until at least 30 minutes of inactivity.
* The GET_IDLETIMEOUT call gives us that time in minutes. We
* want to be sure to keep the stream alive if it is about to die
* due to inactivity.
*/
adj_idle_timeout = 60 * (long) mail_parameters(m,GET_IDLETIMEOUT,NULL);
if(adj_idle_timeout <= 0)
adj_idle_timeout = 600;
adj = (adj_idle_timeout >= 50 * FUDGE) ? 5 * FUDGE :
(adj_idle_timeout >= 30 * FUDGE) ? 3 * FUDGE :
(adj_idle_timeout >= 20 * FUDGE) ? 2 * FUDGE : FUDGE;
adj_idle_timeout = MAX(adj_idle_timeout - adj, 120);
/*
* Set interval to mail-check-interval unless
* mail-check-interval-noncurrent is nonzero and this is not inbox
* or current stream.
*/
if(ps_global->check_interval_for_noncurr > 0
&& m != ps_global->mail_stream
&& !sp_flagged(m, SP_INBOX))
interval = ps_global->check_interval_for_noncurr;
else
interval = timeo;
/*
* We want to make sure that we notice expunges, but we don't have
* to be fanatical about it. Every once in a while we'll do a ping
* because we haven't had a command that notices expunges for a
* while. It's also a larger number than interval so it gives us a
* convenient interval to do slower pinging than interval if we
* are busy.
*/
if(interval <= adj_idle_timeout)
expunged_reaper_to = MIN(MAX(2*interval,180), adj_idle_timeout);
else
expunged_reaper_to = interval;
/*
* User may want to avoid new mail checking while composing.
* In this case we will only do the keepalives.
*/
if(timeo == 0
|| (flags & NM_FROM_COMPOSER
&& ((F_ON(F_QUELL_PINGS_COMPOSING, ps_global)
&& !sp_flagged(m, SP_INBOX))
||
(F_ON(F_QUELL_PINGS_COMPOSING_INBOX, ps_global)
&& sp_flagged(m, SP_INBOX))))){
interval = expunged_reaper_to = 0;
}
dprint((9,
"%s: force=%d interval=%ld exp_reap_to=%ld adj_idle_to=%ld\n",
STREAMNAME(m), force_arg, (long) interval,
(long) expunged_reaper_to, (long) adj_idle_timeout));
dprint((9,
" since_last_ping=%ld since_last_reap=%ld\n",
(long) (now - sp_last_ping(m)),
(long) (now - sp_last_expunged_reaper(m))));
/* if check_point does a check it resets last_ping time */
if(force_arg || (timeo && expunged_reaper_to > 0))
(void) check_point(m, time_for_check_point, flags);
/*
* Remember that unless force_arg is set, this check is really
* only for the current folder. This is usually going to fire
* on the first test, which is the interval the user set.
*/
if(force_arg
||
(timeo
&&
((interval && (now - sp_last_ping(m) >= interval-1))
||
(expunged_reaper_to
&& (now - sp_last_expunged_reaper(m)) >= expunged_reaper_to)
||
(now - sp_last_ping(m) >= adj_idle_timeout)))){
if((flags & NM_STATUS_MSG) && pith_opt_newmail_check_cue)
(*pith_opt_newmail_check_cue)(TRUE);
dprint((7, "Mail_Ping(%s): lastping=%ld er=%ld%s%s %s\n",
STREAMNAME(m),
(long) (now - sp_last_ping(m)),
(long) (now - sp_last_expunged_reaper(m)),
force_arg ? " [forced]" :
interval && (now-sp_last_ping(m) >= interval-1)
? " [it's time]" :
expunged_reaper_to
&& (now - sp_last_expunged_reaper(m) >= expunged_reaper_to)
? " [expunged reaper]"
: " [keepalive]",
m == ps_global->mail_stream ? " [current]" : "",
debug_time(0,1)));
/*
* We're about to ping the stream.
* If the stream is a #move Mail Drop there is a minimum time
* between re-opens of the mail drop to check for new mail.
* If the check is forced by the user, they want it to
* happen now. We use knowledge of c-client internals to
* make this happen.
*/
if(force_arg && m && m->snarf.name)
m->snarf.time = 0;
/*-- Ping the stream to check for new mail --*/
if(sp_dead_stream(m)){
dprint((6, "no check: stream is dead\n"));
}
else if(!pine_mail_ping(m)){
dprint((6, "ping failed: stream is dead\n"));
sp_set_dead_stream(m, 1);
}
dprint((7, "Ping complete: %s\n", debug_time(0,1)));
if((flags & NM_STATUS_MSG) && pith_opt_newmail_check_cue)
(*pith_opt_newmail_check_cue)(FALSE);
}
}
if(nexttime < 0 || nexttime >= ps_global->s_pool.nstream)
nexttime = 0;
i = started_on = nexttime;
do {
m = ps_global->s_pool.streams[i];
nexttime = i;
if(ps_global->s_pool.nstream > 0)
i = (i + 1) % ps_global->s_pool.nstream;
/*
* This do() loop handles all the other streams that weren't covered
* in the for() loop above.
*/
if((!m || m->halfopen) ||
(m == ps_global->mail_stream ||
(force_arg && sp_flagged(m, SP_LOCKED)))){
nexttime = i;
continue;
}
/*
* If it is taking an extra long time to do the pings and checks,
* think about skipping some of them. Always do at least one of
* these non-special streams (if they are due to be pinged).
* The nexttime variable keeps track of where we were so that we
* don't always ping the first one in the list and then skip out.
*/
if((time(0) - now >= 5) && have_pinged_non_special){
dprint((7, "skipping pings due to delay: %s\n",
debug_time(0,1)));
break;
}
nexttime = i;
have_pinged_non_special++;
adj_idle_timeout = 60 * (long) mail_parameters(m,GET_IDLETIMEOUT,NULL);
if(adj_idle_timeout <= 0)
adj_idle_timeout = 600;
adj = (adj_idle_timeout >= 50 * FUDGE) ? 5 * FUDGE :
(adj_idle_timeout >= 30 * FUDGE) ? 3 * FUDGE :
(adj_idle_timeout >= 20 * FUDGE) ? 2 * FUDGE : FUDGE;
adj_idle_timeout = MAX(adj_idle_timeout - adj, 120);
if(ps_global->check_interval_for_noncurr > 0
&& m != ps_global->mail_stream
&& !sp_flagged(m, SP_INBOX))
interval = ps_global->check_interval_for_noncurr;
else
interval = timeo;
if(interval <= adj_idle_timeout)
expunged_reaper_to = MIN(MAX(2*interval,180), adj_idle_timeout);
else
expunged_reaper_to = interval;
if(timeo == 0
|| (flags & NM_FROM_COMPOSER
&& ((F_ON(F_QUELL_PINGS_COMPOSING, ps_global)
&& !sp_flagged(m, SP_INBOX))
||
(F_ON(F_QUELL_PINGS_COMPOSING_INBOX, ps_global)
&& sp_flagged(m, SP_INBOX))))){
interval = expunged_reaper_to = 0;
}
dprint((9,
"%s: force=%d interval=%ld exp_reap_to=%ld adj_idle_to=%ld\n",
STREAMNAME(m), force_arg, (long) interval,
(long) expunged_reaper_to, (long) adj_idle_timeout));
dprint((9,
" since_last_ping=%ld since_last_reap=%ld since_last_input=%ld\n",
(long) (now - sp_last_ping(m)),
(long) (now - sp_last_expunged_reaper(m)),
(long) since_last_input));
/* if check_point does a check it resets last_ping time */
if(force_arg || (timeo && expunged_reaper_to > 0))
(void) check_point(m, time_for_check_point, flags);
/*
* The check here is a little bit different from the current folder
* check in the for() loop above. In particular, we defer our
* pinging for awhile if the last input was recent (except for the
* inbox!). We ping streams which are cached but not actively being
* used (that is, the non-locked streams) at a slower rate.
* If we don't use them for a long time we will eventually close them
* (in maybe_kill_old_stream()) but we do it when we want to instead
* of when the server wants us to by attempting to keep it alive here.
* The other reason to ping the cached streams is that we only get
* told the new mail in those streams is recent one time, the messages
* that weren't handled here will no longer be recent next time
* we open the folder.
*/
if((force_arg && sp_flagged(m, SP_LOCKED))
||
(timeo
&&
((interval
&& sp_flagged(m, SP_LOCKED)
&& ((since_last_input >= 3
&& (now-sp_last_ping(m) >= interval-1))
|| (sp_flagged(m, SP_INBOX)
&& (now-sp_last_ping(m) >= interval-1))))
||
(expunged_reaper_to
&& sp_flagged(m, SP_LOCKED)
&& (now-sp_last_expunged_reaper(m) >= expunged_reaper_to))
||
(expunged_reaper_to
&& !sp_flagged(m, SP_LOCKED)
&& since_last_input >= 3
&& (now-sp_last_ping(m) >= expunged_reaper_to))
||
(now - sp_last_ping(m) >= adj_idle_timeout)))){
if((flags & NM_STATUS_MSG) && pith_opt_newmail_check_cue)
(*pith_opt_newmail_check_cue)(TRUE);
dprint((7,
"Mail_Ping(%s): lastping=%ld er=%ld%s idle: %ld %s\n",
STREAMNAME(m),
(long) (now - sp_last_ping(m)),
(long) (now - sp_last_expunged_reaper(m)),
(force_arg && sp_flagged(m, SP_LOCKED)) ? " [forced]" :
(interval
&& sp_flagged(m, SP_LOCKED)
&& ((since_last_input >= 3
&& (now-sp_last_ping(m) >= interval-1))
|| (sp_flagged(m, SP_INBOX)
&& (now-sp_last_ping(m) >= interval-1))))
? " [it's time]" :
(expunged_reaper_to
&& sp_flagged(m, SP_LOCKED)
&& (now-sp_last_expunged_reaper(m) >= expunged_reaper_to))
? " [expunged reaper]" :
(expunged_reaper_to
&& !sp_flagged(m, SP_LOCKED)
&& since_last_input >= 3
&& (now-sp_last_ping(m) >= expunged_reaper_to))
? " [slow ping]" : " [keepalive]",
since_last_input,
debug_time(0,1)));
/*
* We're about to ping the stream.
* If the stream is a #move Mail Drop there is a minimum time
* between re-opens of the mail drop to check for new mail.
* If the check is forced by the user, they want it to
* happen now. We use knowledge of c-client internals to
* make this happen.
*/
if(force_arg && m && m->snarf.name)
m->snarf.time = 0;
/*-- Ping the stream to check for new mail --*/
if(sp_dead_stream(m)){
dprint((6, "no check: stream is dead\n"));
}
else if(!pine_mail_ping(m)){
dprint((6, "ping failed: stream is dead\n"));
sp_set_dead_stream(m, 1);
}
dprint((7, "Ping complete: %s\n", debug_time(0,1)));
if((flags & NM_STATUS_MSG) && pith_opt_newmail_check_cue)
(*pith_opt_newmail_check_cue)(FALSE);
}
} while(i != started_on);
/*
* Current mail box state changed, could be additions or deletions.
* Also check if we need to do sorting that has been deferred.
* We handle the current stream separately from the rest in the
* similar loop that follows this paragraph.
*/
m = ps_global->mail_stream;
if(sp_mail_box_changed(m) || sp_unsorted_newmail(m)
|| sp_need_to_rethread(m)){
dprint((7,
"Cur new mail, %s, new_mail_count: %ld expunge: %ld, max_msgno: %ld\n",
(m && m->mailbox) ? m->mailbox : "?",
sp_new_mail_count(m),
sp_expunge_count(m),
mn_get_total(sp_msgmap(m))));
new_mail_was_announced = 0;
if(sp_mail_box_changed(m))
fixup_flags(m, sp_msgmap(m));
if(sp_new_mail_count(m))
process_filter_patterns(m, sp_msgmap(m), sp_new_mail_count(m));
/* worry about sorting */
if((sp_new_mail_count(m) > 0L
|| sp_unsorted_newmail(m)
|| sp_need_to_rethread(m))
&& !((flags & NM_DEFER_SORT)
|| any_lflagged(sp_msgmap(m), MN_HIDE)))
refresh_sort(m, sp_msgmap(m),
(flags & NM_STATUS_MSG) ? SRT_VRB : SRT_NON);
else if(sp_new_mail_count(m) > 0L)
sp_set_unsorted_newmail(m, 1);
if(sp_new_mail_count(m) > 0L){
sp_set_mail_since_cmd(m, sp_mail_since_cmd(m)+sp_new_mail_count(m));
rv += (t_nm_count = sp_new_mail_count(m));
sp_set_new_mail_count(m, 0L);
if((flags & NM_STATUS_MSG) && pith_opt_newmail_announce){
for(n = m->nmsgs; n > 1L; n--)
if(!get_lflag(m, NULL, n, MN_EXLD))
break;
(*pith_opt_newmail_announce)(m, n, t_nm_count);
if(n)
new_mail_was_announced++;
}
}
update_folder_unseen_by_stream(m, new_mail_was_announced ? UFU_NONE : UFU_ANNOUNCE);
if(flags & NM_STATUS_MSG)
sp_set_mail_box_changed(m, 0);
}
/* the rest of the streams */
for(i = 0; i < ps_global->s_pool.nstream; i++){
m = ps_global->s_pool.streams[i];
if(!m || m == ps_global->mail_stream)
continue;
if(sp_mail_box_changed(m)){
/*-- New mail for this stream, queue up the notification --*/
dprint((7,
"New mail, %s, new_mail_count: %ld expunge: %ld, max_msgno: %ld\n",
(m && m->mailbox) ? m->mailbox : "?",
sp_new_mail_count(m),
sp_expunge_count(m),
mn_get_total(sp_msgmap(m))));
new_mail_was_announced = 0;
fixup_flags(m, sp_msgmap(m));
if(sp_new_mail_count(m))
process_filter_patterns(m, sp_msgmap(m), sp_new_mail_count(m));
if(sp_new_mail_count(m) > 0){
sp_set_unsorted_newmail(m, 1);
sp_set_mail_since_cmd(m, sp_mail_since_cmd(m) +
sp_new_mail_count(m));
if(sp_flagged(m, SP_LOCKED) && sp_flagged(m, SP_USERFLDR))
rv += (t_nm_count = sp_new_mail_count(m));
sp_set_new_mail_count(m, 0L);
/* messages only for user's streams */
if(flags & NM_STATUS_MSG
&& pith_opt_newmail_announce
&& sp_flagged(m, SP_LOCKED)
&& sp_flagged(m, SP_USERFLDR)){
for(n = m->nmsgs; n > 1L; n--)
if(!get_lflag(m, NULL, n, MN_EXLD))
break;
(*pith_opt_newmail_announce)(m, n, t_nm_count);
if(n)
new_mail_was_announced++;
}
}
update_folder_unseen_by_stream(m, new_mail_was_announced ? UFU_NONE : UFU_ANNOUNCE);
if(flags & NM_STATUS_MSG)
sp_set_mail_box_changed(m, 0);
}
}
/* so quit_screen can tell new mail from expunged mail */
exp_count = sp_expunge_count(ps_global->mail_stream);
/* see if we want to kill any cached streams */
for(i = 0; i < ps_global->s_pool.nstream; i++){
m = ps_global->s_pool.streams[i];
if(sp_last_ping(m) >= now)
maybe_kill_old_stream(m);
}
/*
* This is here to prevent banging on the down arrow key (or holding
* it down and repeating) at the end of the index from causing
* a whole bunch of new mail checks. Last_nextitem_forcechk does get
* set at the place it is tested in mailcmd.c, but this is here to
* reset it to a little bit later in case it takes a second or more
* to check for the mail. If we didn't do this, we'd just check every
* keystroke as long as the checks took more than a second.
*/
if(force_arg)
ps_global->last_nextitem_forcechk = time(0);
dprint((6, "******** new mail returning %ld ********\n",
rv ? rv : (exp_count ? 0 : -1)));
return(rv ? rv : (exp_count ? 0 : -1));
}
/*----------------------------------------------------------------------
Read a character from keyboard with timeout
Input: none
Result: Returns command read via read_char
Times out and returns a null command every so often
Calculates the timeout for the read, and does a few other house keeping
things. The duration of the timeout is set in pine.c.
----------------------------------------------------------------------*/
UCS
read_command(char **utf8str)
{
int tm = 0, more_freq_timeo;
UCS ucs;
long dtime;
static unsigned char utf8buf[7];
unsigned char *newdestp;
/*
* timeo is the mail-check-interval. What we want to do (ignoring the
* messages_queued part) is timeout more often than timeo but only
* check for new mail every timeo or so seconds. The reason we want to
* timeout more often is so that we will have a chance to catch the user
* in an idle period where we can do a check_point(). Otherwise, with
* a default mail-check-interval, we are almost always calling newmail
* right after the user presses a key, making it the worst possible
* time to do a checkpoint.
*/
more_freq_timeo = MIN(get_input_timeout(), IDLE_TIMEOUT);
if(more_freq_timeo == 0)
more_freq_timeo = IDLE_TIMEOUT;
cancel_busy_cue(-1);
tm = (messages_queued(&dtime) > 1) ? (int)dtime : more_freq_timeo;
if(utf8str)
*utf8str = NULL;
ucs = read_char(tm);
if(ucs != NO_OP_COMMAND && ucs != NO_OP_IDLE && ucs != KEY_RESIZE)
zero_new_mail_count();
#ifdef BACKGROUND_POST
/*
* Any expired children to report on?
*/
if(ps_global->post && ps_global->post->pid == 0){
int winner = 0;
if(ps_global->post->status < 0){
q_status_message(SM_ORDER | SM_DING, 3, 3, "Abysmal failure!");
}
else{
(void) pine_send_status(ps_global->post->status,
ps_global->post->fcc, tmp_20k_buf, SIZEOF_20KBUF,
&winner);
q_status_message(SM_ORDER | (winner ? 0 : SM_DING), 3, 3,
tmp_20k_buf);
}
if(!winner)
q_status_message(SM_ORDER, 0, 3,
"Re-send via \"Compose\" then \"Yes\" to \"Continue INTERRUPTED?\"");
if(ps_global->post->fcc)
fs_give((void **) &ps_global->post->fcc);
fs_give((void **) &ps_global->post);
}
#endif
/*
* The character we get from read_char() is a UCS-4 char. Or it could be a special
* value like KEY_UP or NO_OP_IDLE or something similar. From here on out
* we're going to operate with UTF-8 internally. This is the point where we
* convert the UCS-4 input (actually whatever sort of input the user is typing
* was converted to UCS-4 first) to UTF-8. It's easy in this read_command
* case because if user types a non-ascii character as a command it's going to be
* an error. All commands are ascii. In order to present a reasonable error
* message we pass back the UTF-8 string to the caller.
*/
if(ucs >= 0x80 && ucs < KEY_BASE){
/*
* User typed a character that is non-ascii. Convert it to
* UTF-8.
*/
memset(utf8buf, 0, sizeof(utf8buf));
newdestp = utf8_put(utf8buf, (unsigned long) ucs);
if(newdestp - utf8buf > 1){ /* this should happen */
if(utf8str)
*utf8str = (char *) utf8buf;
dprint((9, "Read command: looks like user typed non-ascii command 0x%x %s: returning KEY_UTF8\n", ucs, pretty_command(ucs)));
ucs = KEY_UTF8;
}
else{
dprint((9, "Read command: looks like user typed unknown, non-ascii command 0x%x %s: returning KEY_UNKNOWN\n", ucs, pretty_command(ucs)));
ucs = KEY_UNKNOWN; /* best we can do, shouldn't happen */
}
}
else{
dprint((9, "Read command returning: 0x%x %s\n", ucs, pretty_command(ucs)));
}
return(ucs);
}
int
main(int argc, char *argv[])
#endif
{
UCS c;
register int f;
register int n;
register BUFFER *bp;
int viewflag = FALSE; /* are we starting in view mode?*/
int starton = 0; /* where's dot to begin with? */
int setlocale_collate = 1;
char bname[NBUFN]; /* buffer name of file to read */
char *file_to_edit = NULL;
char *display_charmap = NULL, *dc;
char *keyboard_charmap = NULL;
int use_system = 0;
char *err = NULL;
set_input_timeout(600);
Pmaster = NULL; /* turn OFF composer functionality */
km_popped = 0;
/*
* Read command line flags before initializing, otherwise, we never
* know to init for f_keys...
*/
file_to_edit = pico_args(argc, argv, &starton, &viewflag, &setlocale_collate);
set_collation(setlocale_collate, 1);
#define cpstr(s) strcpy((char *)fs_get(1+strlen(s)), s)
#ifdef _WINDOWS
init_utf8_display(1, NULL);
#else /* UNIX */
if(display_character_set)
display_charmap = cpstr(display_character_set);
#if HAVE_LANGINFO_H && defined(CODESET)
else if((dc = nl_langinfo_codeset_wrapper()) != NULL)
display_charmap = cpstr(dc);
#endif
if(!display_charmap)
display_charmap = cpstr("US-ASCII");
if(keyboard_character_set)
keyboard_charmap = cpstr(keyboard_character_set);
else
keyboard_charmap = cpstr(display_charmap);
if(use_system_translation){
#if PREREQ_FOR_SYS_TRANSLATION
use_system++;
/* This modifies its arguments */
if(setup_for_input_output(use_system, &display_charmap, &keyboard_charmap,
&input_cs, &err) == -1){
fprintf(stderr, "%s\n", err ? err : "trouble with character set");
exit(1);
}
else if(err){
fprintf(stderr, "%s\n", err);
fs_give((void **) &err);
}
#endif
}
if(!use_system){
if(setup_for_input_output(use_system, &display_charmap, &keyboard_charmap,
&input_cs, &err) == -1){
fprintf(stderr, "%s\n", err ? err : "trouble with character set");
exit(1);
}
else if(err){
fprintf(stderr, "%s\n", err);
fs_give((void **) &err);
}
}
if(keyboard_charmap){
set_locale_charmap(keyboard_charmap);
free((void *) keyboard_charmap);
}
if(display_charmap)
free((void *) display_charmap);
#endif /* UNIX */
/*
* There are a couple arguments that we need to be sure
* are converted for internal use.
*/
if(alt_speller)
alt_speller = cpstr(fname_to_utf8(alt_speller));
if(opertree && opertree[0]){
strncpy(opertree, fname_to_utf8(opertree), sizeof(opertree));
opertree[sizeof(opertree)-1] = '\0';
}
if(glo_quote_str_orig)
glo_quote_str = utf8_to_ucs4_cpystr(fname_to_utf8(glo_quote_str_orig));
if(glo_wordseps_orig)
glo_wordseps = utf8_to_ucs4_cpystr(fname_to_utf8(glo_wordseps_orig));
if(file_to_edit)
file_to_edit = cpstr(fname_to_utf8(file_to_edit));
#undef cpstr
#if defined(DOS) || defined(OS2)
if(file_to_edit){ /* strip quotes? */
int l;
if(strchr("'\"", file_to_edit[0])
&& (l = strlen(file_to_edit)) > 1
&& file_to_edit[l-1] == file_to_edit[0]){
file_to_edit[l-1] = '\0'; /* blat trailing quote */
file_to_edit++; /* advance past leading quote */
}
}
#endif
if(!vtinit()) /* Displays. */
exit(1);
strncpy(bname, "main", sizeof(bname)); /* default buffer name */
bname[sizeof(bname)-1] = '\0';
edinit(bname); /* Buffers, windows. */
update(); /* let the user know we are here */
#ifdef _WINDOWS
mswin_setwindow(NULL, NULL, NULL, NULL, NULL, NULL);
mswin_showwindow();
mswin_showcaret(1); /* turn on for main window */
mswin_allowpaste(MSWIN_PASTE_FULL);
mswin_setclosetext("Use the ^X command to exit Pico.");
mswin_setscrollcallback (pico_scroll_callback);
#endif
#if defined(USE_TERMCAP) || defined(USE_TERMINFO) || defined(VMS)
if(kbesc == NULL){ /* will arrow keys work ? */
(*term.t_putchar)('\007');
emlwrite("Warning: keypad keys may be non-functional", NULL);
}
#endif /* USE_TERMCAP/USE_TERMINFO/VMS */
if(file_to_edit){ /* Any file to edit? */
makename(bname, file_to_edit); /* set up a buffer for this file */
bp = curbp; /* read in first file */
makename(bname, file_to_edit);
strncpy(bp->b_bname, bname, sizeof(bp->b_bname));
bp->b_bname[sizeof(bp->b_bname)-1] = '\0';
if(strlen(file_to_edit) >= NFILEN){
char buf[128];
snprintf(buf, sizeof(buf), "Filename \"%.10s...\" too long", file_to_edit);
emlwrite(buf, NULL);
file_to_edit = NULL;
}
else{
strncpy(bp->b_fname, file_to_edit, sizeof(bp->b_fname));
bp->b_fname[sizeof(bp->b_fname)-1] = '\0';
if (((gmode&MDTREE) && !in_oper_tree(file_to_edit)) ||
readin(file_to_edit, (viewflag==FALSE), TRUE) == ABORT) {
if ((gmode&MDTREE) && !in_oper_tree(file_to_edit)){
EML eml;
eml.s = opertree;
emlwrite(_("Can't read file from outside of %s"), &eml);
}
file_to_edit = NULL;
}
}
if(!file_to_edit){
strncpy(bp->b_bname, "main", sizeof(bp->b_bname));
bp->b_bname[sizeof(bp->b_bname)-1] = '\0';
strncpy(bp->b_fname, "", sizeof(bp->b_fname));
bp->b_fname[sizeof(bp->b_fname)-1] = '\0';
}
bp->b_dotp = bp->b_linep;
bp->b_doto = 0;
if (viewflag) /* set the view mode */
bp->b_mode |= MDVIEW;
}
/* setup to process commands */
lastflag = 0; /* Fake last flags. */
curbp->b_mode |= gmode; /* and set default modes*/
curwp->w_flag |= WFMODE; /* and force an update */
if(timeoutset){
EML eml;
eml.s = comatose(get_input_timeout());
emlwrite(_("Checking for new mail every %s seconds"), &eml);
}
forwline(0, starton - 1); /* move dot to specified line */
while(1){
if(km_popped){
km_popped--;
if(km_popped == 0) /* cause bottom three lines to be repainted */
curwp->w_flag |= WFHARD;
}
if(km_popped){ /* temporarily change to cause menu to be painted */
term.t_mrow = 2;
curwp->w_ntrows -= 2;
curwp->w_flag |= WFMODE;
movecursor(term.t_nrow-2, 0); /* clear status line, too */
peeol();
}
update(); /* Fix up the screen */
if(km_popped){
term.t_mrow = 0;
curwp->w_ntrows += 2;
}
#ifdef MOUSE
#ifdef EX_MOUSE
/* New mouse function for real mouse text seletion. */
register_mfunc(mouse_in_pico, 2, 0, term.t_nrow - (term.t_mrow + 1),
term.t_ncol);
#else
mouse_in_content(KEY_MOUSE, -1, -1, 0, 0);
register_mfunc(mouse_in_content, 2, 0, term.t_nrow - (term.t_mrow + 1),
term.t_ncol);
#endif
#endif
#ifdef _WINDOWS
mswin_setdndcallback (pico_file_drop);
mswin_mousetrackcallback(pico_cursor);
#endif
c = GetKey();
#ifdef MOUSE
#ifdef EX_MOUSE
clear_mfunc(mouse_in_pico);
#else
clear_mfunc(mouse_in_content);
#endif
#endif
#ifdef _WINDOWS
mswin_cleardndcallback ();
mswin_mousetrackcallback(NULL);
#endif
if(timeoutset && (c == NODATA || time_to_check())){
if(pico_new_mail())
emlwrite(_("You may possibly have new mail."), NULL);
}
if(km_popped)
switch(c){
case NODATA:
case (CTRL|'L'):
km_popped++;
break;
default:
/* clear bottom three lines */
mlerase();
break;
}
if(c == NODATA)
continue;
if(mpresf){ /* erase message line? */
if(mpresf++ > MESSDELAY)
mlerase();
}
f = FALSE;
n = 1;
#ifdef MOUSE
clear_mfunc(mouse_in_content);
#endif
/* Do it. */
execute(normalize_cmd(c, fkm, 1), f, n);
}
}