void prompt(const char *s)
{
/** prompt user for input on LINES-3 line, left justified **/
PutLine(LINES-3,0,s);
CleartoEOLN();
}
/*----------------------------------------------------------------------
Clear specified line on the screen
Result: The line is blanked and the cursor is left at column 0.
----*/
void
ClearLine(int n)
{
if(ps_global->in_init_seq)
return;
MoveCursor(n, 0);
CleartoEOLN();
}
/*----------------------------------------------------------------------
----*/
void
radio_help(int line, int column, HelpType help)
{
char **text;
/* assumption here is that HelpType is char ** */
text = help;
if(text == NULL)
return;
MoveCursor(line + 1, column);
CleartoEOLN();
if(text[0])
PutLine0(line + 1, column, text[0]);
MoveCursor(line + 2, column);
CleartoEOLN();
if(text[1])
PutLine0(line + 2, column, text[1]);
fflush(stdout);
}
void
clear_message(
void)
{
if (!cmd_line) {
MoveCursor(cLINES, 0);
CleartoEOLN();
cursoroff();
#ifndef USE_CURSES
my_flush();
#endif /* !USE_CURSES */
}
}
int
optionally_enter(char *utf8string, int y_base, int x_base, int utf8string_size,
char *utf8prompt, ESCKEY_S *escape_list, HelpType help, int *flags)
{
UCS *string = NULL, ucs;
size_t string_size;
UCS *s2;
UCS *saved_original = NULL;
char *candidate;
UCS *kill_buffer = NULL;
UCS *k, *kb;
int field_pos; /* offset into array dline.vl */
int i, j, return_v, cols, prompt_width, too_thin,
real_y_base, km_popped, passwd;
char **help_text;
long fkey_table[12];
struct key_menu *km;
bitmap_t bitmap;
COLOR_PAIR *lastc = NULL, *promptc = NULL;
struct variable *vars = ps_global->vars;
struct display_line dline;
#ifdef _WINDOWS
int cursor_shown;
#endif
dprint((5, "=== optionally_enter called ===\n"));
dprint((9, "utf8string:\"%s\" y:%d x:%d length: %d append: %d\n",
utf8string ? utf8string : "",
x_base, y_base, utf8string_size,
(flags && *flags & OE_APPEND_CURRENT)));
dprint((9, "passwd:%d utf8prompt:\"%s\" label:\"%s\"\n",
(flags && *flags & OE_PASSWD_NOAST) ? 10 :
(flags && *flags & OE_PASSWD) ? 1 : 0,
utf8prompt ? utf8prompt : "",
(escape_list && escape_list[0].ch != -1 && escape_list[0].label)
? escape_list[0].label: ""));
if(!ps_global->ttyo)
return(pre_screen_config_opt_enter(utf8string, utf8string_size, utf8prompt,
escape_list, help, flags));
#ifdef _WINDOWS
if (mswin_usedialog ())
return(win_dialog_opt_enter(utf8string, utf8string_size, utf8prompt,
escape_list, help, flags));
#endif
/*
* Utf8string comes in as UTF-8. We'll convert it to a UCS-4 array and operate on
* that array, then convert it back before returning. Utf8string_size is the size
* of the utf8string array but that doesn't help us much for the array we need to
* operate on here. We'll just allocate a big array and then cut it off when
* sending it back.
*
* This should come before the specialized calls above but those aren't
* converted to use UCS-4 yet.
*/
string = utf8_to_ucs4_cpystr(utf8string);
dline.vused = ucs4_strlen(string);
string_size = (2 * MAX(utf8string_size,dline.vused) + 100);
fs_resize((void **) &string, string_size * sizeof(UCS));
suspend_busy_cue();
cols = ps_global->ttyo->screen_cols;
prompt_width = utf8_width(utf8prompt);
too_thin = 0;
km_popped = 0;
if(y_base > 0)
real_y_base = y_base;
else{
real_y_base = y_base + ps_global->ttyo->screen_rows;
real_y_base = MAX(real_y_base, 0);
}
flush_ordered_messages();
mark_status_dirty();
if(flags && *flags & OE_APPEND_CURRENT) /* save a copy in case of cancel */
saved_original = ucs4_cpystr(string);
/*
* build the function key mapping table, skipping predefined keys...
*/
memset(fkey_table, NO_OP_COMMAND, 12 * sizeof(long));
for(i = 0, j = 0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
if(i+j == OE_HELP_KEY)
j++;
if(i+j == OE_CANCEL_KEY)
j++;
if(i+j == OE_ENTER_KEY)
j++;
fkey_table[i+j] = escape_list[i].ch;
}
/* assumption that HelpType is char ** */
help_text = help;
if(help_text){ /*---- Show help text -----*/
int width = ps_global->ttyo->screen_cols - x_base;
if(FOOTER_ROWS(ps_global) == 1){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
clearfooter(ps_global);
y_base = -3;
real_y_base = y_base + ps_global->ttyo->screen_rows;
}
for(j = 0; j < 2 && help_text[j]; j++){
MoveCursor(real_y_base + 1 + j, x_base);
CleartoEOLN();
if(width < utf8_width(help_text[j])){
char *tmp = cpystr(help_text[j]);
(void) utf8_truncate(tmp, width);
PutLine0(real_y_base + 1 + j, x_base, tmp);
fs_give((void **) &tmp);
}
else
PutLine0(real_y_base + 1 + j, x_base, help_text[j]);
}
}
else{
clrbitmap(bitmap);
clrbitmap((km = &oe_keymenu)->bitmap); /* force formatting */
if(!(flags && (*flags) & OE_DISALLOW_HELP))
setbitn(OE_HELP_KEY, bitmap);
setbitn(OE_ENTER_KEY, bitmap);
if(!(flags && (*flags) & OE_DISALLOW_CANCEL))
setbitn(OE_CANCEL_KEY, bitmap);
setbitn(OE_CTRL_T_KEY, bitmap);
/*---- Show the usual possible keys ----*/
for(i=0,j=0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
if(i+j == OE_HELP_KEY)
j++;
if(i+j == OE_CANCEL_KEY)
j++;
if(i+j == OE_ENTER_KEY)
j++;
oe_keymenu.keys[i+j].label = escape_list[i].label;
oe_keymenu.keys[i+j].name = escape_list[i].name;
setbitn(i+j, bitmap);
}
for(i = i+j; i < 12; i++)
if(!(i == OE_HELP_KEY || i == OE_ENTER_KEY || i == OE_CANCEL_KEY))
oe_keymenu.keys[i].name = NULL;
draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global), 0, FirstMenu);
}
if(pico_usingcolor() && VAR_PROMPT_FORE_COLOR &&
VAR_PROMPT_BACK_COLOR &&
pico_is_good_color(VAR_PROMPT_FORE_COLOR) &&
pico_is_good_color(VAR_PROMPT_BACK_COLOR)){
lastc = pico_get_cur_color();
if(lastc){
promptc = new_color_pair(VAR_PROMPT_FORE_COLOR,
VAR_PROMPT_BACK_COLOR);
(void)pico_set_colorp(promptc, PSC_NONE);
}
}
else
StartInverse();
/*
* if display length isn't wide enough to support input,
* shorten up the prompt...
*/
if((dline.dwid = cols - (x_base + prompt_width)) < MIN_OPT_ENT_WIDTH){
char *p;
unsigned got_width;
/*
* Scoot prompt pointer forward at least (MIN_OPT_ENT_WIDTH - dline.dwid) screencells.
*/
p = utf8_count_forw_width(utf8prompt, MIN_OPT_ENT_WIDTH-dline.dwid, &got_width);
if(got_width < MIN_OPT_ENT_WIDTH-dline.dwid)
p = utf8_count_forw_width(utf8prompt, MIN_OPT_ENT_WIDTH+1-dline.dwid, &got_width);
if(p){
prompt_width = utf8_width(p);
dline.dwid = cols - (x_base + prompt_width);
utf8prompt = p;
}
}
/*
* How many UCS-4 characters will we need to make up the width dwid? It could be
* unlimited because of zero-width characters, I suppose, but realistically it
* isn't going to be much more than dwid.
*/
dline.dlen = 2 * dline.dwid + 100;
dline.dl = (UCS *) fs_get(dline.dlen * sizeof(UCS));
dline.olddl = (UCS *) fs_get(dline.dlen * sizeof(UCS));
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
dline.movecursor = MoveCursor;
dline.writechar = Writewchar;
dline.row = real_y_base;
dline.col = x_base + prompt_width;
dline.vl = string;
dline.vlen = --string_size; /* -1 for terminating zero */
dline.vbase = field_pos = 0;
#ifdef _WINDOWS
cursor_shown = mswin_showcaret(1);
#endif
PutLine0(real_y_base, x_base, utf8prompt);
/*
* If appending, position field_pos at end of input.
*/
if(flags && *flags & OE_APPEND_CURRENT)
while(string[field_pos])
field_pos++;
passwd = (flags && *flags & OE_PASSWD_NOAST) ? 10 :
(flags && *flags & OE_PASSWD) ? 1 : 0;
line_paint(field_pos, &dline, &passwd);
/*----------------------------------------------------------------------
The main loop
loops until someone sets the return_v.
----------------------------------------------------------------------*/
return_v = -10;
while(return_v == -10) {
#ifdef MOUSE
mouse_in_content(KEY_MOUSE, -1, -1, 0x5, 0);
register_mfunc(mouse_in_content,
real_y_base, x_base + prompt_width,
real_y_base, ps_global->ttyo->screen_cols);
#endif
#ifdef _WINDOWS
mswin_allowpaste(MSWIN_PASTE_LINE);
g_mc_row = real_y_base;
g_mc_col = x_base + prompt_width;
mswin_mousetrackcallback(pcpine_oe_cursor);
#endif
/* Timeout 10 min to keep imap mail stream alive */
ps_global->conceal_sensitive_debugging = passwd ? 1 : 0;
ucs = read_char(600);
ps_global->conceal_sensitive_debugging = 0;
#ifdef MOUSE
clear_mfunc(mouse_in_content);
#endif
#ifdef _WINDOWS
mswin_allowpaste(MSWIN_PASTE_DISABLE);
mswin_mousetrackcallback(NULL);
#endif
/*
* Don't want to intercept all characters if typing in passwd.
* We select an ad hoc set that we will catch and let the rest
* through. We would have caught the set below in the big switch
* but we skip the switch instead. Still catch things like ^K,
* DELETE, ^C, RETURN.
*/
if(passwd)
switch(ucs){
case ctrl('F'):
case KEY_RIGHT:
case ctrl('B'):
case KEY_LEFT:
case ctrl('U'):
case ctrl('A'):
case KEY_HOME:
case ctrl('E'):
case KEY_END:
case TAB:
goto ok_for_passwd;
}
if(too_thin && ucs != KEY_RESIZE && ucs != ctrl('Z') && ucs != ctrl('C'))
goto bleep;
switch(ucs){
/*--------------- KEY RIGHT ---------------*/
case ctrl('F'):
case KEY_RIGHT:
if(field_pos >= string_size || string[field_pos] == '\0')
goto bleep;
line_paint(++field_pos, &dline, &passwd);
break;
/*--------------- KEY LEFT ---------------*/
case ctrl('B'):
case KEY_LEFT:
if(field_pos <= 0)
goto bleep;
line_paint(--field_pos, &dline, &passwd);
break;
/*-------------------- WORD SKIP --------------------*/
case ctrl('@'):
/*
* Note: read_char *can* return NO_OP_COMMAND which is
* the def'd with the same value as ^@ (NULL), BUT since
* read_char has a big timeout (>25 secs) it won't.
*/
/* skip thru current word */
while(string[field_pos]
&& isalnum((unsigned char) string[field_pos]))
field_pos++;
/* skip thru current white space to next word */
while(string[field_pos]
&& !isalnum((unsigned char) string[field_pos]))
field_pos++;
line_paint(field_pos, &dline, &passwd);
break;
/*-------------------- RETURN --------------------*/
case PF4:
if(F_OFF(F_USE_FK,ps_global)) goto bleep;
case ctrl('J'):
case ctrl('M'):
return_v = 0;
break;
/*-------------------- Destructive backspace --------------------*/
case '\177': /* DEL */
case ctrl('H'):
/* Try and do this with by telling the terminal to delete a
a character. If that fails, then repaint the rest of the
line, acheiving the same much less efficiently
*/
if(field_pos <= 0)
goto bleep;
field_pos--;
/* drop thru to pull line back ... */
/*-------------------- Delete char --------------------*/
case ctrl('D'):
case KEY_DEL:
if(field_pos >= string_size || !string[field_pos])
goto bleep;
dline.vused--;
for(s2 = &string[field_pos]; *s2 != 0; s2++)
*s2 = s2[1];
*s2 = 0; /* Copy last NULL */
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
break;
/*--------------- Kill line -----------------*/
case ctrl('K'):
if(kill_buffer != NULL)
fs_give((void **) &kill_buffer);
if(field_pos != 0 || string[0]){
if(!passwd && F_ON(F_DEL_FROM_DOT, ps_global))
dline.vused -= ucs4_strlen(&string[i = field_pos]);
else
dline.vused = i = 0;
kill_buffer = ucs4_cpystr(&string[field_pos = i]);
string[field_pos] = '\0';
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
}
break;
/*------------------- Undelete line --------------------*/
case ctrl('U'):
if(kill_buffer == NULL)
goto bleep;
/* Make string so it will fit */
kb = ucs4_cpystr(kill_buffer);
if(ucs4_strlen(kb) + ucs4_strlen(string) > string_size)
kb[string_size - ucs4_strlen(string)] = '\0';
if(string[field_pos] == '\0') {
/*--- adding to the end of the string ----*/
for(k = kb; *k; k++)
string[field_pos++] = *k;
string[field_pos] = '\0';
}
else{
int shift;
shift = ucs4_strlen(kb);
/* shift field_pos ... end to right */
for(k = &string[field_pos] + ucs4_strlen(&string[field_pos]);
k >= &string[field_pos]; k--)
*(k+shift) = *k;
for(k = kb; *k; k++)
string[field_pos++] = *k;
}
if(*kb && flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
dline.vused = ucs4_strlen(string);
fs_give((void **) &kb);
line_paint(field_pos, &dline, &passwd);
break;
/*-------------------- Interrupt --------------------*/
case ctrl('C'): /* ^C */
if(F_ON(F_USE_FK,ps_global) || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
goto bleep;
goto cancel;
case PF2:
if(F_OFF(F_USE_FK,ps_global) || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
goto bleep;
cancel:
return_v = 1;
if(saved_original){
for(i = 0; saved_original[i]; i++)
string[i] = saved_original[i];
string[i] = 0;
}
break;
case ctrl('A'):
case KEY_HOME:
/*-------------------- Start of line -------------*/
line_paint(field_pos = 0, &dline, &passwd);
break;
case ctrl('E'):
case KEY_END:
/*-------------------- End of line ---------------*/
line_paint(field_pos = dline.vused, &dline, &passwd);
break;
/*-------------------- Help --------------------*/
case ctrl('G') :
case PF1:
if(flags && ((*flags) & OE_DISALLOW_HELP))
goto bleep;
else if(FOOTER_ROWS(ps_global) == 1 && km_popped == 0){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
clearfooter(ps_global);
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global),
0, FirstMenu);
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
mark_keymenu_dirty();
y_base = -3;
dline.row = real_y_base = y_base + ps_global->ttyo->screen_rows;
PutLine0(real_y_base, x_base, utf8prompt);
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
line_paint(field_pos, &dline, &passwd);
break;
}
if(FOOTER_ROWS(ps_global) > 1){
mark_keymenu_dirty();
return_v = 3;
}
else
goto bleep;
break;
#ifdef MOUSE
/* Mouse support untested in pine 5.00 */
case KEY_MOUSE :
{
MOUSEPRESS mp;
int w;
mouse_get_last (NULL, &mp);
switch(mp.button){
case M_BUTTON_LEFT : /* position cursor */
mp.col -= dline.col;
/*
* We have to figure out which character is under the cursor.
* This is complicated by the fact that characters may
* be other than one cell wide.
*/
/* the -1 is for the '<' when text is offscreen left */
w = (dline.vbase > 0) ? mp.col-1 : mp.col;
if(mp.col <= 0)
field_pos = dline.vbase - 1;
else{
if(dline.vused <= dline.vbase
|| ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vused-1) <= w)
field_pos = dline.vused;
else{
/*
* Find index of 1st character that causes the
* width to be > w.
*/
for(i = 0;
ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vbase+i) <= w;
i++)
;
field_pos = dline.vbase + i;
}
}
field_pos = MIN(MAX(field_pos, 0), dline.vused);
/* just allow line_paint to choose vbase */
line_paint(field_pos, &dline, &passwd);
break;
case M_BUTTON_RIGHT :
#ifdef _WINDOWS
/*
* Same as M_BUTTON_LEFT except we paste in text after
* moving the cursor.
*/
mp.col -= dline.col;
/* the -1 is for the '<' when text is offscreen left */
w = (dline.vbase > 0) ? mp.col-1 : mp.col;
if(mp.col <= 0)
field_pos = dline.vbase - 1;
else{
if(dline.vused <= dline.vbase
|| ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vused-1) <= w)
field_pos = dline.vused;
else{
/*
* Find index of 1st character that causes the
* width to be > w.
*/
for(i = 0;
ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vbase+i) <= w;
i++)
;
field_pos = dline.vbase + i;
}
}
field_pos = MIN(MAX(field_pos, 0), dline.vused);
line_paint(field_pos, &dline, &passwd);
mswin_allowpaste(MSWIN_PASTE_LINE);
mswin_paste_popup();
mswin_allowpaste(MSWIN_PASTE_DISABLE);
break;
#endif
case M_BUTTON_MIDDLE : /* NO-OP for now */
default: /* just ignore */
break;
}
}
break;
#endif
case NO_OP_IDLE:
/*
* Keep mail stream alive by checking for new mail.
* If we're asking for a password in a login prompt
* we don't want to check for new_mail because the
* new mail check might be what got us here in the first
* place (because of a filter trying to save a message).
* If we need to wait for the user to come back then
* the caller will just have to deal with the failure
* to login.
*/
i = -1;
if(!ps_global->no_newmail_check_from_optionally_enter)
i = new_mail(0, 2, NM_DEFER_SORT);
if(sp_expunge_count(ps_global->mail_stream) &&
flags && ((*flags) & OE_SEQ_SENSITIVE))
goto cancel;
if(i < 0){
line_paint(field_pos, &dline, &passwd);
break; /* no changes, get on with life */
}
/* Else fall into redraw */
/*-------------------- Redraw --------------------*/
case ctrl('L'):
/*---------------- re size ----------------*/
case KEY_RESIZE:
dline.row = real_y_base = y_base > 0 ? y_base :
y_base + ps_global->ttyo->screen_rows;
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
ClearScreen();
redraw_titlebar();
if(ps_global->redrawer != (void (*)(void))NULL)
(*ps_global->redrawer)();
redraw_keymenu();
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
PutLine0(real_y_base, x_base, utf8prompt);
cols = ps_global->ttyo->screen_cols;
too_thin = 0;
if(cols < x_base + prompt_width + 4){
Writechar(BELL, 0);
PutLine0(real_y_base, 0, "Screen's too thin. Ouch!");
too_thin = 1;
}
else{
dline.col = x_base + prompt_width;
dline.dwid = cols - (x_base + prompt_width);
dline.dlen = 2 * dline.dwid + 100;
fs_resize((void **) &dline.dl, (size_t) dline.dlen * sizeof(UCS));
fs_resize((void **) &dline.olddl, (size_t) dline.dlen * sizeof(UCS));
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
line_paint(field_pos, &dline, &passwd);
}
fflush(stdout);
dprint((9,
"optionally_enter RESIZE new_cols:%d too_thin: %d\n",
cols, too_thin));
break;
case PF3 : /* input to potentially remap */
case PF5 :
case PF6 :
case PF7 :
case PF8 :
case PF9 :
case PF10 :
case PF11 :
case PF12 :
if(F_ON(F_USE_FK,ps_global)
&& fkey_table[ucs - PF1] != NO_OP_COMMAND)
ucs = fkey_table[ucs - PF1]; /* remap function key input */
default:
if(escape_list){ /* in the escape key list? */
for(j=0; escape_list[j].ch != -1; j++){
if(escape_list[j].ch == ucs){
return_v = escape_list[j].rval;
break;
}
}
if(return_v != -10)
break;
}
if(ucs < 0x80 && FILTER_THIS((unsigned char) ucs)){
bleep:
putc(BELL, stdout);
continue;
}
ok_for_passwd:
/*--- Insert a character -----*/
if(dline.vused >= string_size)
goto bleep;
/*---- extending the length of the string ---*/
for(s2 = &string[++dline.vused]; s2 - string > field_pos; s2--)
*s2 = *(s2-1);
string[field_pos++] = ucs;
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
} /*---- End of switch on char ----*/
}
#ifdef _WINDOWS
if(!cursor_shown)
mswin_showcaret(0);
#endif
if(dline.dl)
fs_give((void **) &dline.dl);
if(dline.olddl)
fs_give((void **) &dline.olddl);
if(saved_original)
fs_give((void **) &saved_original);
if(kill_buffer)
fs_give((void **) &kill_buffer);
/*
* Change string back into UTF-8.
*/
candidate = ucs4_to_utf8_cpystr(string);
if(string)
fs_give((void **) &string);
if(candidate){
strncpy(utf8string, candidate, utf8string_size);
utf8string[utf8string_size-1] = '\0';
fs_give((void **) &candidate);
}
if (!(flags && (*flags) & OE_KEEP_TRAILING_SPACE))
removing_trailing_white_space(utf8string);
if(lastc){
(void)pico_set_colorp(lastc, PSC_NONE);
free_color_pair(&lastc);
if(promptc)
free_color_pair(&promptc);
}
else
EndInverse();
MoveCursor(real_y_base, x_base); /* Move the cursor to show we're done */
fflush(stdout);
resume_busy_cue(0);
if(km_popped){
FOOTER_ROWS(ps_global) = 1;
clearfooter(ps_global);
ps_global->mangled_body = 1;
}
return(return_v);
}
/*----------------------------------------------------------------------
Prompt user for a choice among alternatives
Args -- utf8prompt: The prompt for the question/selection
line: The line to prompt on, if negative then relative to bottom
esc_list: ESC_KEY_S list of keys
dflt: The selection when the <CR> is pressed (should probably
be one of the chars in esc_list)
on_ctrl_C: The selection when ^C is pressed
help_text: Text to be displayed on bottom two lines
flags: Logically OR'd flags modifying our behavior to:
RB_FLUSH_IN - Discard any pending input chars.
RB_ONE_TRY - Only give one chance to answer. Returns
on_ctrl_C value if not answered acceptably
on first try.
RB_NO_NEWMAIL - Quell the usual newmail check.
RB_SEQ_SENSITIVE - The caller is sensitive to sequence number
changes so return on_ctrl_C if an
unsolicited expunge happens while we're
viewing a message.
RB_RET_HELP - Instead of the regular internal handling
way of handling help_text, this just causes
radio_buttons to return 3 when help is
asked for, so that the caller handles it
instead.
Note: If there are enough keys in the esc_list to need a second
screen, and there is no help, then the 13th key will be
put in the help position.
Result -- Returns the letter pressed. Will be one of the characters in the
esc_list argument, or dflt, or on_ctrl_C, or SEQ_EXCEPTION.
This will pause for any new status message to be seen and then prompt the user.
The prompt will be truncated to fit on the screen. Redraw and resize are
handled along with ^Z suspension. Typing ^G will toggle the help text on and
off. Character types that are not buttons will result in a beep (unless one_try
is set).
----*/
int
radio_buttons(char *utf8prompt, int line, ESCKEY_S *esc_list, int dflt,
int on_ctrl_C, HelpType help_text, int flags)
{
UCS ucs;
register int ch, real_line;
char *q, *ds = NULL;
unsigned maxcol;
int max_label, i, start, fkey_table[12];
int km_popped = 0;
struct key rb_keys[12];
struct key_menu rb_keymenu;
bitmap_t bitmap;
struct variable *vars = ps_global->vars;
COLOR_PAIR *lastc = NULL, *promptc = NULL;
#ifdef _WINDOWS
int cursor_shown;
if (mswin_usedialog()){
MDlgButton button_list[25];
LPTSTR free_names[25];
LPTSTR free_labels[25];
int b, i, ret;
char **help;
memset(&free_names, 0, sizeof(LPTSTR) * 25);
memset(&free_labels, 0, sizeof(LPTSTR) * 25);
memset(&button_list, 0, sizeof (MDlgButton) * 25);
b = 0;
if(flags & RB_RET_HELP){
if(help_text != NO_HELP)
alpine_panic("RET_HELP and help in radio_buttons!");
button_list[b].ch = '?';
button_list[b].rval = 3;
button_list[b].name = TEXT("?");
free_labels[b] = utf8_to_lptstr(N_("Help"));
button_list[b].label = free_labels[b];
++b;
}
for(i = 0; esc_list && esc_list[i].ch != -1 && i < 23; ++i){
if(esc_list[i].ch != -2){
button_list[b].ch = esc_list[i].ch;
button_list[b].rval = esc_list[i].rval;
free_names[b] = utf8_to_lptstr(esc_list[i].name);
button_list[b].name = free_names[b];
free_labels[b] = utf8_to_lptstr(esc_list[i].label);
button_list[b].label = free_labels[b];
++b;
}
}
button_list[b].ch = -1;
/* assumption here is that HelpType is char ** */
help = help_text;
ret = mswin_select(utf8prompt, button_list, dflt, on_ctrl_C, help, flags);
for(i = 0; i < 25; i++){
if(free_names[i])
fs_give((void **) &free_names[i]);
if(free_labels[i])
fs_give((void **) &free_labels[i]);
}
return (ret);
}
#endif /* _WINDOWS */
suspend_busy_cue();
flush_ordered_messages(); /* show user previous status msgs */
mark_status_dirty(); /* clear message next display call */
real_line = line > 0 ? line : ps_global->ttyo->screen_rows + line;
MoveCursor(real_line, RAD_BUT_COL);
CleartoEOLN();
/*---- Find widest label ----*/
max_label = 0;
for(i = 0; esc_list && esc_list[i].ch != -1 && i < 11; i++){
if(esc_list[i].ch == -2) /* -2 means to skip this key and leave blank */
continue;
if(esc_list[i].name)
max_label = MAX(max_label, utf8_width(esc_list[i].name));
}
if(ps_global->ttyo->screen_cols - max_label - 1 > 0)
maxcol = ps_global->ttyo->screen_cols - max_label - 1;
else
maxcol = 0;
/*
* We need to be able to truncate q, so copy it in case it is
* a readonly string.
*/
q = cpystr(utf8prompt);
/*---- Init structs for keymenu ----*/
for(i = 0; i < 12; i++)
memset((void *)&rb_keys[i], 0, sizeof(struct key));
memset((void *)&rb_keymenu, 0, sizeof(struct key_menu));
rb_keymenu.how_many = 1;
rb_keymenu.keys = rb_keys;
/*---- Setup key menu ----*/
start = 0;
clrbitmap(bitmap);
memset(fkey_table, NO_OP_COMMAND, 12 * sizeof(int));
if(flags & RB_RET_HELP && help_text != NO_HELP)
alpine_panic("RET_HELP and help in radio_buttons!");
/* if shown, always at position 0 */
if(help_text != NO_HELP || flags & RB_RET_HELP){
rb_keymenu.keys[0].name = "?";
rb_keymenu.keys[0].label = N_("Help");
setbitn(0, bitmap);
fkey_table[0] = ctrl('G');
start++;
}
if(on_ctrl_C){
rb_keymenu.keys[1].name = "^C";
rb_keymenu.keys[1].label = N_("Cancel");
setbitn(1, bitmap);
fkey_table[1] = ctrl('C');
start++;
}
start = start ? 2 : 0;
/*---- Show the usual possible keys ----*/
for(i=start; esc_list && esc_list[i-start].ch != -1; i++){
/*
* If we have an esc_list item we'd like to put in the non-existent
* 13th slot, and there is no help, we put it in the help slot
* instead. We're hacking now...!
*
* We may also have invisible esc_list items that don't show up
* on the screen. We use this when we have two different keys
* which are synonyms, like ^P and KEY_UP. If all the slots are
* already full we can still fit invisible keys off the screen to
* the right. A key is invisible if it's label is "".
*/
if(i >= 12){
if(esc_list[i-start].label
&& esc_list[i-start].label[0] != '\0'){ /* visible */
if(i == 12){ /* special case where we put it in help slot */
if(help_text != NO_HELP)
alpine_panic("Programming botch in radio_buttons(): too many keys");
if(esc_list[i-start].ch != -2)
setbitn(0, bitmap); /* the help slot */
fkey_table[0] = esc_list[i-start].ch;
rb_keymenu.keys[0].name = esc_list[i-start].name;
if(esc_list[i-start].ch != -2
&& esc_list[i-start].rval == dflt
&& esc_list[i-start].label){
size_t l;
l = strlen(esc_list[i-start].label) + 2;
ds = (char *)fs_get((l+1) * sizeof(char));
snprintf(ds, l+1, "[%s]", esc_list[i-start].label);
ds[l] = '\0';
rb_keymenu.keys[0].label = ds;
}
else
rb_keymenu.keys[0].label = esc_list[i-start].label;
}
else
alpine_panic("Botch in radio_buttons(): too many keys");
}
}
else{
if(esc_list[i-start].ch != -2)
setbitn(i, bitmap);
fkey_table[i] = esc_list[i-start].ch;
rb_keymenu.keys[i].name = esc_list[i-start].name;
if(esc_list[i-start].ch != -2
&& esc_list[i-start].rval == dflt
&& esc_list[i-start].label){
size_t l;
l = strlen(esc_list[i-start].label) + 2;
ds = (char *)fs_get((l+1) * sizeof(char));
snprintf(ds, l+1, "[%s]", esc_list[i-start].label);
ds[l] = '\0';
rb_keymenu.keys[i].label = ds;
}
else
rb_keymenu.keys[i].label = esc_list[i-start].label;
}
}
for(; i < 12; i++)
rb_keymenu.keys[i].name = NULL;
ps_global->mangled_footer = 1;
#ifdef _WINDOWS
cursor_shown = mswin_showcaret(1);
#endif
if(pico_usingcolor() && VAR_PROMPT_FORE_COLOR &&
VAR_PROMPT_BACK_COLOR &&
pico_is_good_color(VAR_PROMPT_FORE_COLOR) &&
pico_is_good_color(VAR_PROMPT_BACK_COLOR)){
lastc = pico_get_cur_color();
if(lastc){
promptc = new_color_pair(VAR_PROMPT_FORE_COLOR,
VAR_PROMPT_BACK_COLOR);
(void)pico_set_colorp(promptc, PSC_NONE);
}
}
else
StartInverse();
draw_radio_prompt(real_line, RAD_BUT_COL, maxcol, q);
while(1){
fflush(stdout);
/*---- Paint the keymenu ----*/
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
draw_keymenu(&rb_keymenu, bitmap, ps_global->ttyo->screen_cols,
1 - FOOTER_ROWS(ps_global), 0, FirstMenu);
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
MoveCursor(real_line, MIN(RAD_BUT_COL+utf8_width(q), maxcol+1));
if(flags & RB_FLUSH_IN)
flush_input();
newcmd:
/* Timeout 5 min to keep imap mail stream alive */
ucs = read_char(600);
dprint((2,
"Want_to read: %s (0x%x)\n", pretty_command(ucs), ucs));
if((ucs < 0x80) && isupper((unsigned char) ucs))
ucs = tolower((unsigned char) ucs);
if(F_ON(F_USE_FK,ps_global)
&& (((ucs < 0x80) && isalpha((unsigned char) ucs) && !strchr("YyNn",(int) ucs))
|| ((ucs >= PF1 && ucs <= PF12)
&& (ucs = fkey_table[ucs - PF1]) == NO_OP_COMMAND))){
/*
* The funky test above does two things. It maps
* esc_list character commands to function keys, *and* prevents
* character commands from input while in function key mode.
* NOTE: this breaks if we ever need more than the first
* twelve function keys...
*/
if(flags & RB_ONE_TRY){
ch = ucs = on_ctrl_C;
goto out_of_loop;
}
Writechar(BELL, 0);
continue;
}
switch(ucs){
default:
for(i = 0; esc_list && esc_list[i].ch != -1; i++)
if(ucs == esc_list[i].ch){
int len, n;
MoveCursor(real_line,len=MIN(RAD_BUT_COL+utf8_width(q),maxcol+1));
for(n = 0, len = ps_global->ttyo->screen_cols - len;
esc_list[i].label && esc_list[i].label[n] && len > 0;
n++, len--)
Writechar(esc_list[i].label[n], 0);
ch = esc_list[i].rval;
goto out_of_loop;
}
if(flags & RB_ONE_TRY){
ch = on_ctrl_C;
goto out_of_loop;
}
Writechar(BELL, 0);
break;
case ctrl('M'):
case ctrl('J'):
ch = dflt;
for(i = 0; esc_list && esc_list[i].ch != -1; i++)
if(ch == esc_list[i].rval){
int len, n;
MoveCursor(real_line,len=MIN(RAD_BUT_COL+utf8_width(q),maxcol+1));
for(n = 0, len = ps_global->ttyo->screen_cols - len;
esc_list[i].label && esc_list[i].label[n] && len > 0;
n++, len--)
Writechar(esc_list[i].label[n], 0);
break;
}
goto out_of_loop;
case ctrl('C'):
if(on_ctrl_C || (flags & RB_ONE_TRY)){
ch = on_ctrl_C;
goto out_of_loop;
}
Writechar(BELL, 0);
break;
case '?':
case ctrl('G'):
if(FOOTER_ROWS(ps_global) == 1 && km_popped == 0){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
line = -3;
real_line = ps_global->ttyo->screen_rows + line;
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
clearfooter(ps_global);
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
draw_radio_prompt(real_line, RAD_BUT_COL, maxcol, q);
break;
}
if(flags & RB_RET_HELP){
ch = 3;
goto out_of_loop;
}
else if(help_text != NO_HELP && FOOTER_ROWS(ps_global) > 1){
mark_keymenu_dirty();
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
MoveCursor(real_line + 1, RAD_BUT_COL);
CleartoEOLN();
MoveCursor(real_line + 2, RAD_BUT_COL);
CleartoEOLN();
radio_help(real_line, RAD_BUT_COL, help_text);
sleep(5);
MoveCursor(real_line, MIN(RAD_BUT_COL+utf8_width(q), maxcol+1));
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
}
else
Writechar(BELL, 0);
break;
case NO_OP_COMMAND:
goto newcmd; /* misunderstood escape? */
case NO_OP_IDLE: /* UNODIR, keep the stream alive */
if(flags & RB_NO_NEWMAIL)
goto newcmd;
i = new_mail(0, VeryBadTime, NM_DEFER_SORT);
if(sp_expunge_count(ps_global->mail_stream)
&& flags & RB_SEQ_SENSITIVE){
if(on_ctrl_C)
ch = on_ctrl_C;
else
ch = SEQ_EXCEPTION;
goto out_of_loop;
}
if(i < 0)
break; /* no changes, get on with life */
/* Else fall into redraw to adjust displayed numbers and such */
case KEY_RESIZE:
case ctrl('L'):
real_line = line > 0 ? line : ps_global->ttyo->screen_rows + line;
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
ClearScreen();
redraw_titlebar();
if(ps_global->redrawer != NULL)
(*ps_global->redrawer)();
if(FOOTER_ROWS(ps_global) == 3 || km_popped)
redraw_keymenu();
if(ps_global->ttyo->screen_cols - max_label - 1 > 0)
maxcol = ps_global->ttyo->screen_cols - max_label - 1;
else
maxcol = 0;
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
draw_radio_prompt(real_line, RAD_BUT_COL, maxcol, q);
break;
} /* switch */
}
out_of_loop:
#ifdef _WINDOWS
if(!cursor_shown)
mswin_showcaret(0);
#endif
fs_give((void **) &q);
if(ds)
fs_give((void **) &ds);
if(lastc){
(void) pico_set_colorp(lastc, PSC_NONE);
free_color_pair(&lastc);
if(promptc)
free_color_pair(&promptc);
}
else
EndInverse();
fflush(stdout);
resume_busy_cue(0);
if(km_popped){
FOOTER_ROWS(ps_global) = 1;
clearfooter(ps_global);
ps_global->mangled_body = 1;
}
return(ch);
}
void alias(void)
{
/*
* Work with alias commands...
*/
char name[NLEN], *address, buffer[SLEN];
char *commap;
static int newaliases = 0;
int ch, i;
int nutitle = 0;
int too_long;
/*
* We're going to try to match the way elm does it at
* he main menu. I probably won't be able to use any
* main menu routines, but I will "borrow" from them. RLH
*/
alias_main_state(); /* Save globals for return to main menu */
open_alias_files(FALSE); /* First, read the alias files. RLH */
alias_screen(newaliases);
while (1) {
redraw = 0;
nucurr = 0;
nufoot = 0;
prompt(nls_Prompt);
CleartoEOLN();
ch = GetKey(0);
MoveCursor(LINES-3,strlen(nls_Prompt)); CleartoEOS();
dprint(3, (debugfile, "\n-- Alias command: %c\n\n", ch));
switch (ch) {
case '?': redraw += alias_help(); break;
#ifdef ALLOW_SUBSHELL
case '!' : WriteChar('!');
alias_main_state(); /** reload index screen vars **/
redraw += subshell();
alias_main_state(); /** reload alias screen vars **/
break;
#endif /* ALLOW_SUBSHELL */
case '$': PutLine(-1, -1, catgets(elm_msg_cat,
AliasesSet, AliasesResync,
"Resynchronize aliases..."));
/*
* Process deletions and then see if we need to
* re-run the "newalias" routine.
*/
if (resync_aliases(newaliases)) {
install_aliases();
newaliases = 0;
redraw++;
}
break;
case 'a': PutLine(-1, -1, catgets(elm_msg_cat,
AliasesSet, AliasesAddCurrent,
"Add address from current message..."));
clear_error();
if (add_current_alias()) {
newaliases++;
nutitle++;
}
break;
case 'c':
if (curr_alias > 0) {
PutLine(-1, -1, catgets(elm_msg_cat,
AliasesSet, AliasesReplaceCurrent,
"Replace current alias in database..."));
clear_error();
if (add_alias(TRUE, curr_alias-1)) {
newaliases++;
nutitle++;
}
}
else {
show_error(catgets(elm_msg_cat,
AliasesSet, AliasesNoneToReplace,
"Warning: no aliases to replace!"));
}
break;
case 'e': PutLine(LINES-3, strlen(nls_Prompt),
catgets(elm_msg_cat, AliasesSet, AliasesEdit,
"Edit %s..."), ALIAS_TEXT);
/*
* Process aliases.text for deletions, etc. You
* have to do this *before* checking current because
* all aliases could be marked for deletion.
*/
(void) resync_aliases(newaliases);
if (edit_aliases_text()) {
newaliases = 0;
}
redraw++;
break;
case 'm':
if (curr_alias > 0) {
PutLine(-1, -1, catgets(elm_msg_cat,
AliasesSet, AliasesMail, "Mail..."));
redraw += a_sendmsg();
}
else {
show_error(catgets(elm_msg_cat,
AliasesSet, AliasesNoneToMail,
"Warning: no aliases to send mail to!"));
}
break;
case 'n': PutLine(-1, -1, catgets(elm_msg_cat,
AliasesSet, AliasesAddNew,
"Add a new alias to database..."));
clear_error();
if (add_alias(FALSE, -1)) {
newaliases++;
nutitle++;
}
break;
case 'q':
case 'Q':
case 'i':
case 'I':
case 'r':
case 'R': PutLine(-1, -1, catgets(elm_msg_cat,
AliasesSet, AliasesAddReturn,
"Return to main menu..."));
/*
* leaving the alias system. Must check for
* pending deletes, etc. prompt is set to FALSE
* on uppercase letters so that deletions are
* NOT queried.
*/
if (delete_aliases(newaliases, islower(ch))) {
install_aliases();
newaliases = 0;
}
clear_error();
alias_main_state(); /* Done with aliases. */
return;
case RETURN:
case LINE_FEED:
case ' ':
case 'v':
if (newaliases) { /* Need this ?? */
show_error(catgets(elm_msg_cat,
AliasesSet, AliasesNotInstalled,
"Warning: new aliases not installed yet!"));
}
if (curr_alias > 0) {
if (aliases[curr_alias-1]->type & GROUP) {
PutLine(LINES-1, 0, catgets(elm_msg_cat,
AliasesSet, AliasesGroupAlias,
"Group alias: %-60.60s"),
aliases[curr_alias-1]->address);
}
else {
PutLine(LINES-1, 0, catgets(elm_msg_cat,
AliasesSet, AliasesAliasedAddress,
"Aliased address: %-60.60s"),
aliases[curr_alias-1]->address);
}
}
else {
show_error(catgets(elm_msg_cat,
AliasesSet, AliasesNoneToView,
"Warning: no aliases to view!"));
}
break;
case 'x':
case 'X': PutLine(-1, -1, catgets(elm_msg_cat,
AliasesSet, AliasesAddReturn,
"Return to main menu..."));
exit_alias();
clear_error();
alias_main_state(); /* Done with aliases. */
return;
case 'f':
case 'F':
if (curr_alias > 0) {
clear_error();
strcpy(name, aliases[curr_alias-1]->alias);
if (ch == 'F') {
strcpy(buffer, catgets(elm_msg_cat,
AliasesSet, AliasesFullyExpanded,
"Fully expand alias: "));
PutLine(LINES-2, 0, buffer);
if (enter_string(name, sizeof(name), -1, -1,
ESTR_REPLACE) < 0 || name[0] == '\0')
break;
}
too_long = FALSE;
address = get_alias_address(name, TRUE, &too_long);
if (address != NULL) {
while (TRUE) {
ClearScreen();
PutLine(2,0, catgets(elm_msg_cat,
AliasesSet, AliasesAliasedFull,
"Aliased address for:\t%s\n\r"),
name);
i = 4;
while (i < LINES-2) {
if ((commap = strchr(address, (int)','))
== NULL) {
PutLine(i, 4, address);
break;
}
*commap = '\0';
PutLine(i++, 4, address);
address = commap+2;
}
PutLine(LINES-1, 0, catgets(elm_msg_cat,
AliasesSet, AliasesPressReturn,
"Press <return> to continue."));
(void) ReadCh();
if (commap == NULL) {
redraw++;
break;
}
}
}
else if (! too_long) {
show_error(catgets(elm_msg_cat,
AliasesSet, AliasesNotFound,
"Not found."));
}
}
else {
show_error(catgets(elm_msg_cat,
AliasesSet, AliasesNoneToView,
"Warning: no aliases to view!"));
}
break;
case KEY_REDRAW:
redraw = 1;
break;
/*
* None of the menu specific commands were chosen, therefore
* it must be a "motion" command (or an error).
*/
default : motion(ch);
}
if (redraw) { /* Redraw screen if necessary */
alias_screen(newaliases);
nutitle = 0;
}
if (nutitle) { /* Redraw title if necessary */
alias_title(newaliases);
nutitle = 0;
}
check_range();
if (nucurr == NEW_PAGE)
show_headers();
else if (nucurr == SAME_PAGE)
show_current();
else if (nufoot) {
if (mini_menu) {
MoveCursor(LINES-7, 0);
CleartoEOS();
show_alias_menu();
}
else {
MoveCursor(LINES-4, 0);
CleartoEOS();
}
show_last_error(); /* for those operations that have to
* clear the footer except for a message.
*/
}
} /* BIG while loop... */
}
static int add_current_alias(void)
{
/*
* Alias the current message to the specified name and
* add it to the alias text file, for processing as
* the user leaves the program.
*
* Returns non-zero iff alias actually added to file.
*/
char aliasname[SLEN], firstname[SLEN], lastname[SLEN];
char comment[SLEN], address1[LONG_STRING], buffer[SLEN];
char comment_buff[LONG_STRING];
char *chspace, *bufptr;
struct header_rec *current_header;
static char bad_punc[] = ",.:;";
char *punc_ptr;
int i, match;
int replace, to_replace;
if (curr_folder.curr_mssg == 0) {
dprint(4, (debugfile,
"Add current alias called without any current message!\n"));
show_error(catgets(elm_msg_cat, AliasesSet, AliasesNoMessage,
"No message to alias to!"));
return(0);
}
current_header = curr_folder.headers[curr_folder.curr_mssg-1];
strcpy(buffer, catgets(elm_msg_cat, AliasesSet, AliasesCurrentMessage,
"Current message address aliased to: "));
PutLine(LINES-2,0, buffer);
CleartoEOLN();
*aliasname = '\0';
if ((replace = get_aliasname(aliasname, buffer, &to_replace)) < 0) {
dprint(3, (debugfile,
"Aliasname [%s] was rejected in add_current_alias\n",
aliasname));
ClearLine(LINES-2);
return(0);
}
/* use full name in current message for default comment */
tail_of(current_header->from, comment_buff, current_header->to);
if(strchr(comment_buff, (int)'!') || strchr(comment_buff, (int)'@'))
/* never mind - it's an address not a full name */
*comment_buff = '\0';
/*
* Try to break up the From: comment into firstname, lastname, and
* any other text. This is based on the fact that many address
* comments are pretty straightforward. This will break on many
* situations. Should handle:
* (Robert Howard)
* (Robert L. Howard)
* (Robert Howard, Georgia Tech)
* pretty well. Will break on:
* (The Voice of Reason)
* and others....
*/
*firstname = '\0';
*lastname = '\0';
*comment = '\0';
if (strlen(comment_buff) != 0) { /* There is something. */
bufptr = comment_buff;
while (*bufptr == ' ') bufptr++; /* Always strip leading WS */
if ((chspace = strchr(bufptr, ' ')) != NULL) {
/*
* A space means that there is at least (firstname lastname)
* Get firstname and move bufptr.
*/
*chspace = '\0';
strcpy(firstname, bufptr);
bufptr = chspace + 1; /* Move the pointer */
while (*bufptr == ' ') bufptr++;
}
above: if ((chspace = strchr(bufptr, ' ')) != NULL) {
/*
* Another space means a third+ word. We either have:
* 1. Word 3+ is a comment, or
* 2. Word 2 is a middle initial (word 3 is lastname).
* Check and see.
*/
*chspace = '\0';
if ((strlen(bufptr) == 1) ||
(strlen(bufptr) == 2 && *(bufptr+1) == '.')) {
/*
* If the second word is either a single
* character or a character followed by '.' it was
* probably a middle initial. Add it to firstname
* and shift.
*/
strcat(firstname, " ");
strcat(firstname, bufptr);
bufptr = chspace + 1; /* Move the pointer */
while (*bufptr == ' ') bufptr++;
goto above;
}
strcpy(lastname, bufptr);
bufptr = chspace + 1; /* Move the pointer */
while (*bufptr == ' ') bufptr++;
strcpy(comment, bufptr);
}
else {
/*
* Only a lastname left.
*/
strcpy(lastname, bufptr);
}
/*
* Finally, get any puctuation characters off the end of
* lastname.
*/
match = TRUE;
for (i = strlen(lastname) - 1; match && i>0; i--) {
match = FALSE;
for (punc_ptr = bad_punc; *punc_ptr != '\0'; punc_ptr++) {
if (lastname[i] == *punc_ptr) {
lastname[i] = '\0';
match = TRUE;
break;
}
}
}
}
get_realnames(aliasname, firstname, lastname, comment, buffer);
/* grab the return address of this message */
get_return(address1, curr_folder.curr_mssg-1);
strcpy(address1, strip_parens(address1)); /* remove parens! */
return(ask_accept(aliasname, firstname, lastname, comment, address1,
buffer, replace, to_replace));
}
static int add_alias(int replace, int to_replace)
{
/*
* Add an alias to the user alias text file. If there
* are aliases tagged, the user is asked if he wants to
* create a group alias from the tagged files.
*
* Return zero if alias not added in actuality.
*
* If replace == FALSE, then we will ask for the new
* aliasname.
*
* If replace == TRUE, then we are replacing the alias
* denoted by to_replace.
*
* Note that even if replace == FALSE, if the user types
* in the name of a current alias then we can still do
* a replacement.
*/
int i, ans;
int tagged = 0;
int leftoff = 0;
char aliasname[SLEN], firstname[SLEN], lastname[SLEN];
char address1[LONG_STRING], buffer[SLEN];
char comment[LONG_STRING];
char *ch_ptr;
/*
* See if there are any tagged aliases.
*/
for (i=0; i < num_aliases; i++) {
if (ison(aliases[i]->status, TAGGED)) {
if (tagged == 0) leftoff = i;
tagged++;
}
}
if (tagged == 1) {
/*
* There is only on alias tagged. Ask the question
* but the default response is NO.
*/
PutLine(LINES-2,0, catgets(elm_msg_cat,
AliasesSet, AliasesOneTagged,
"There is 1 alias tagged..."));
CleartoEOLN();
ans = enter_yn(catgets(elm_msg_cat, AliasesSet, AliasesCreateGroup,
"Create group alias?"), FALSE, LINES-3, FALSE);
}
else if (tagged > 1) {
/*
* If multiple tagged aliases then we assume the user
* wants to create a group alias. The default response
* is YES.
*/
PutLine(LINES-2,0, catgets(elm_msg_cat,
AliasesSet, AliasesManyTagged,
"There are %d aliases tagged..."), tagged);
CleartoEOLN();
ans = enter_yn(catgets(elm_msg_cat, AliasesSet, AliasesCreateGroup,
"Create group alias?"), TRUE, LINES-3, FALSE);
} else {
/*
* Nothing tagged ... thus nothing to make a group of.
*/
ans = FALSE;
}
/*
* If requested above, create the group alias address.
*/
if (ans) {
strcpy(address1, aliases[leftoff]->alias);
for (i=leftoff+1; i < num_aliases; i++) {
if (ison(aliases[i]->status, TAGGED)) {
strcat(address1, ",");
strcat(address1, aliases[i]->alias);
}
}
}
else {
tagged = 0;
}
/*
* Only ask for an aliasname if we are NOT replacing the
* current alias.
*/
if (replace) {
strcpy(aliasname, aliases[to_replace]->alias);
/*
* First, see if what we are replacing is a SYSTEM
* alias. If so, we need to ask a question.
*/
if(aliases[to_replace]->type & SYSTEM) {
dprint(3, (debugfile,
"Aliasname [%s] is SYSTEM in add_alias\n", aliasname));
/*
* If they don't want to superceed the SYSTEM alias then
* just return.
*/
if( ! superceed_system(to_replace)) {
ClearLine(LINES-2);
return(0);
}
}
}
else {
strcpy(buffer, catgets(elm_msg_cat,
AliasesSet, AliasesEnterAliasName, "Enter alias name: "));
PutLine(LINES-2,0, buffer);
CleartoEOLN();
*aliasname = '\0';
if ((replace = get_aliasname(aliasname, buffer, &to_replace)) < 0) {
dprint(3, (debugfile,
"Aliasname [%s] was rejected in add_alias\n", aliasname));
ClearLine(LINES-2);
return(0);
}
}
/*
* If we are replacing an existing alias, we will assume that
* they might want to be just editing most of what is already
* there. So we copy some defaults from the existing alias.
*/
if (replace) {
strcpy(lastname, aliases[to_replace]->last_name);
strcpy(firstname, aliases[to_replace]->name);
ch_ptr = strstr(firstname, lastname);
*(ch_ptr-1) = '\0';
strcpy(comment, aliases[to_replace]->comment);
}
else {
*lastname = '\0';
*firstname = '\0';
*comment = '\0';
}
get_realnames(aliasname, firstname, lastname, comment, buffer);
/*
* Since there are no tagged aliases, we must ask for an
* address. If we are replacing, a default address is
* presented.
*/
if (tagged == 0) {
sprintf(buffer, catgets(elm_msg_cat,
AliasesSet, AliasesEnterAddress,
"Enter address for %s: "), aliasname);
PutLine(LINES-2, 0, buffer);
if (replace)
strcpy(address1, aliases[to_replace]->address);
else
*address1 = '\0';
if (enter_string(address1, sizeof(address1), -1, -1,
ESTR_REPLACE) < 0 || address1[0] == '\0') {
Raw(ON);
show_error(catgets(elm_msg_cat, AliasesSet, AliasesNoAddressSpec,
"No address specified!"));
return(0);
}
Raw(ON);
despace_address(address1);
clear_error(); /* Just in case */
}
if(ask_accept(aliasname, firstname, lastname, comment, address1,
buffer, replace, to_replace)) {
/*
* We can only clear the tags after we know that the
* alias was added. This allows the user to back out
* and rethink without losing the tags.
*/
if (tagged > 0) {
for (i=leftoff; i < num_aliases; i++) {
if (ison(aliases[i]->status, TAGGED)) {
clearit(aliases[i]->status, TAGGED);
show_msg_tag(i);
}
}
}
return(1);
}
else {
return(0);
}
}
static int ask_accept(char *aliasname, char *firstname, char *lastname,
char *comment, char *address, char *buffer,
int replace, int replacement)
{
int ans;
char *(old_alias[1]);
/*
* If firstname == lastname, they probably just took all
* the deafaults. We *assume* they don't want lastname
* entered twice, so we will truncate it.
*/
if (strcmp(firstname, lastname) == 0) {
*firstname = '\0';
}
if (strlen(firstname) == 0) {
strcpy(buffer, lastname);
}
else {
sprintf(buffer, "%s %s", firstname, lastname);
}
PutLine(LINES-1,0, catgets(elm_msg_cat, AliasesSet, AliasesAddressAs,
"Messages addressed as: %s (%s)"), address, buffer);
if (strlen(comment) != 0) {
strcat(buffer, ", ");
strcat(buffer, comment);
}
PutLine(LINES-2,0, catgets(elm_msg_cat, AliasesSet, AliasesAddressTo,
"New alias: %s is '%s'."), aliasname, buffer);
CleartoEOLN();
/*
* Kludge Alert: Spaces are padded to the front of the prompt
* to write over the previous question. Should probably record
* the end of the line, move to it, and CleartoEOLN() it.
*/
ans = enter_yn(catgets(elm_msg_cat, AliasesSet, AliasesAcceptNew,
" Accept new alias?"), TRUE, LINES-3, FALSE);
if(ans) {
if (replace) {
old_alias[0] = aliases[replacement]->alias;
/*
* First, clear flag if this is marked to be deleted.
* This prevents the problem where they marked it for
* deletion and then figured out that it could be
* c)hanged but didn't explicitly U)ndelete it. Without
* this test, the resync action would then delete
* the new alias we just so carefully added to the
* text file.
*/
if (ison(aliases[replacement]->status, DELETED)) {
clearit(aliases[replacement]->status, DELETED);
}
/*
* Changed aliases are given the NEW flag.
*/
setit(aliases[replacement]->status, NEW);
show_msg_status(replacement);
/*
* Now we can delete it...
*/
delete_from_alias_text(old_alias, 1);
/*
* Kludge Alert: We need to get the trailing comma
* (added in delete_from_alias_text()) off of the
* alias since the display won't be re-sync'd right
* away.
*/
*((old_alias[0])+strlen(old_alias[0])-1) = '\0';
}
add_to_alias_text(aliasname, firstname, lastname, comment, address);
}
ClearLine(LINES-2);
ClearLine(LINES-1);
return ans;
}
static int get_aliasname(char *aliasname, char *buffer, int *duplicate)
{
/*
* Have the user enter an aliasname, check to see if it
* is legal, then check for duplicates. If a duplicate
* is found offer to replace existing alias.
*
* Return values:
*
* -1 Either the aliasname was zero length, had bad
* characters and was a duplicate which the user
* chose not to replace.
*
* 0 A new alias was entered successfully.
*
* 1 The entered alias was an existing USER alias
* that the user has chosen to replace. In this
* case the alias to replace is passed back in
* in the variable 'duplicate'.
*/
int loc;
do {
if (enter_string(aliasname, SLEN,
LINES-2, strlen(buffer), ESTR_REPLACE) < 0
|| aliasname[0] == '\0')
return(-1);
} while (check_alias(aliasname) == -1);
clear_error(); /* Just in case */
/*
* Check to see if there is already a USER alias by this name.
*/
if ((loc = find_alias(aliasname, USER)) >= 0) {
dprint(3, (debugfile,
"Attempt to add a duplicate alias [%s] in get_aliasname\n",
aliases[loc]->alias));
if (aliases[loc]->type & GROUP )
PutLine(LINES-2,0, catgets(elm_msg_cat,
AliasesSet, AliasesAlreadyGroup,
"Already a group with name %s."), aliases[loc]->alias);
else
PutLine(LINES-2,0, catgets(elm_msg_cat,
AliasesSet, AliasesAlreadyAlias,
"Already an alias for %s."), aliases[loc]->alias);
CleartoEOLN();
/*
* If they don't want to replace the alias by that name
* then just return.
*/
if (!enter_yn(catgets(elm_msg_cat, AliasesSet,
AliasesReplaceExisting,
"Replace existing alias?"), FALSE, LINES-3, FALSE))
return(-1);
*duplicate = loc;
return(1);
}
/*
* If they have elected to replace an existing alias then
* we assume that they would also elect to superceed a
* system alias by that name (since they have already
* done so). So we don't even bother to check or ask.
*
* Of course we do check if there was no USER alias match.
*/
if ((loc = find_alias(aliasname, SYSTEM)) >= 0) {
dprint(3, (debugfile,
"Attempt to add a duplicate system alias [%s] in get_aliasname\n",
aliases[loc]->address));
if( ! superceed_system(loc))
return(-1);
}
return(0);
}
int
subshell()
{
/** spawn a subshell with either the specified command
returns non-zero if screen rewrite needed
**/
char command[SLEN];
int old_raw, helpful, ret;
helpful = (user_level == 0);
if (helpful)
PutLine0(LINES-3, COLUMNS-40, catgets(elm_msg_cat, ElmSet, ElmUseShellName,
"(Use the shell name for a shell.)"));
PutLine0(LINES-2, 0, catgets(elm_msg_cat, ElmSet, ElmShellCommand,
"Shell command: "));
CleartoEOS();
command[0] = '\0';
(void) optionally_enter(command, LINES-2, 15, FALSE, FALSE);
if (command[0] == 0) {
if (helpful)
MoveCursor(LINES-3,COLUMNS-40);
else
MoveCursor(LINES-2,0);
CleartoEOS();
return 0;
}
MoveCursor(LINES,0);
CleartoEOLN();
if ((old_raw = RawState()) == ON)
Raw(OFF);
softkeys_off();
if (cursor_control)
transmit_functions(OFF);
umask(original_umask); /* restore original umask so users new files are ok */
ret = system_call(command, SY_USER_SHELL|SY_ENAB_SIGINT|SY_DUMPSTATE);
umask(077); /* now put it back to private for mail files */
SetXYLocation(0, 40); /* a location not near the next request, so an absolute is used */
PutLine0(LINES, 0, catgets(elm_msg_cat, ElmSet, ElmPressAnyKeyToReturn,
"\n\nPress any key to return to ELM: "));
Raw(ON | NO_TITE);
(void) getchar();
printf("\r\n");
Raw(OFF | NO_TITE); /* Done even if old_raw == ON, to get ti/te right */
if (old_raw == ON)
Raw(ON);
softkeys_on();
if (cursor_control)
transmit_functions(ON);
if (ret)
error1(catgets(elm_msg_cat, ElmSet, ElmReturnCodeWas,
"Return code was %d."), ret);
return 1;
}
char *
tin_getline(
const char *prompt,
int number_only, /* 1=positive numbers only, 2=negative too */
const char *str,
int max_chars,
t_bool passwd,
int which_hist)
{
int c, i, loc, tmp, gl_max;
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
wint_t wc;
#else
char *buf = gl_buf;
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
is_passwd = passwd;
set_xclick_off();
if (prompt == NULL)
prompt = "";
gl_buf[0] = 0; /* used as end of input indicator */
gl_fixup(-1, 0); /* this resets gl_fixup */
gl_width = cCOLS - strlen(prompt);
gl_prompt = prompt;
gl_pos = gl_cnt = 0;
if (max_chars == 0) {
if (number_only)
gl_max = 6;
else
gl_max = BUF_SIZE;
} else
gl_max = max_chars;
my_fputs(prompt, stdout);
cursoron();
my_flush();
if (gl_in_hook) {
loc = gl_in_hook(gl_buf);
if (loc >= 0)
gl_fixup(0, BUF_SIZE);
}
if (!cmd_line && gl_max == BUF_SIZE)
CleartoEOLN();
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
if (str != NULL) {
wchar_t wbuf[LEN];
if (mbstowcs(wbuf, str, ARRAY_SIZE(wbuf) - 1) != (size_t) -1) {
wbuf[ARRAY_SIZE(wbuf) - 1] = (wchar_t) '\0';
for (i = 0; wbuf[i]; i++)
gl_addwchar(wbuf[i]);
}
}
while ((wc = ReadWch()) != WEOF) {
if ((gl_cnt < gl_max) && iswprint(wc)) {
if (number_only) {
if (iswdigit(wc)) {
gl_addwchar(wc);
/* Minus */
} else if (number_only == 2 && gl_pos == 0 && wc == (wint_t) '-') {
gl_addwchar(wc);
} else {
ring_bell();
}
} else
gl_addwchar(wc);
} else {
c = (int) wc;
switch (wc) {
#else
if (str != NULL) {
for (i = 0; str[i]; i++)
gl_addchar(str[i]);
}
while ((c = ReadCh()) != EOF) {
c &= 0xff;
if ((gl_cnt < gl_max) && my_isprint(c)) {
if (number_only) {
if (isdigit(c)) {
gl_addchar(c);
/* Minus */
} else if (number_only == 2 && gl_pos == 0 && c == '-') {
gl_addchar(c);
} else {
ring_bell();
}
} else
gl_addchar(c);
} else {
switch (c) {
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
case ESC: /* abort */
#ifdef HAVE_KEY_PREFIX
case KEY_PREFIX:
#endif /* HAVE_KEY_PREFIX */
switch (get_arrow_key(c)) {
case KEYMAP_UP:
case KEYMAP_PAGE_UP:
hist_prev(which_hist);
break;
case KEYMAP_PAGE_DOWN:
case KEYMAP_DOWN:
hist_next(which_hist);
break;
case KEYMAP_RIGHT:
gl_fixup(-1, gl_pos + 1);
break;
case KEYMAP_LEFT:
gl_fixup(-1, gl_pos - 1);
break;
case KEYMAP_HOME:
gl_fixup(-1, 0);
break;
case KEYMAP_END:
gl_fixup(-1, gl_cnt);
break;
case KEYMAP_DEL:
gl_del(0);
break;
case KEYMAP_INS:
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
gl_addwchar((wint_t) ' ');
#else
gl_addchar(' ');
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
break;
default:
return (char *) 0;
}
break;
case '\n': /* newline */
case '\r':
gl_newline(which_hist);
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
wcstombs(buf, gl_buf, BUF_SIZE - 1);
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
return buf;
case CTRL_A:
gl_fixup(-1, 0);
break;
case CTRL_B:
gl_fixup(-1, gl_pos - 1);
break;
case CTRL_D:
if (gl_cnt == 0) {
gl_buf[0] = 0;
my_fputc('\n', stdout);
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
wcstombs(buf, gl_buf, BUF_SIZE - 1);
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
return buf;
} else
gl_del(0);
break;
case CTRL_E:
gl_fixup(-1, gl_cnt);
break;
case CTRL_F:
gl_fixup(-1, gl_pos + 1);
break;
case CTRL_H:
case DEL:
gl_del(-1);
break;
case TAB:
if (gl_tab_hook) {
tmp = gl_pos;
loc = gl_tab_hook(gl_buf, strlen(gl_prompt), &tmp);
if (loc >= 0 || tmp != gl_pos)
gl_fixup(loc, tmp);
}
break;
case CTRL_W:
gl_kill_back_word();
break;
case CTRL_U:
gl_fixup(-1, 0);
/* FALLTHROUGH */
case CTRL_K:
gl_kill();
break;
case CTRL_L:
case CTRL_R:
gl_redraw();
break;
case CTRL_N:
hist_next(which_hist);
break;
case CTRL_P:
hist_prev(which_hist);
break;
default:
ring_bell();
break;
}
}
}
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
wcstombs(buf, gl_buf, BUF_SIZE - 1);
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
return buf;
}
/*
* adds the character c to the input buffer at current location if
* the character is in the allowed template of characters
*/
static void
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
gl_addwchar(
wint_t wc)
#else
gl_addchar(
int c)
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
{
int i;
/*
* Crashing is always the worst solution IMHO. So as a quick hack,
* ignore characters silently, if buffer is full. To allow a final
* newline, leave space for one more character. Just a hack too.
* This was the original code:
*
if (gl_cnt >= BUF_SIZE - 1) {
error_message("tin_getline: input buffer overflow");
giveup();
}
*/
if (gl_cnt >= BUF_SIZE - 2)
return;
for (i = gl_cnt; i >= gl_pos; i--)
gl_buf[i + 1] = gl_buf[i];
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
gl_buf[gl_pos] = (wchar_t) wc;
#else
gl_buf[gl_pos] = c;
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
gl_fixup(gl_pos, gl_pos + 1);
}
/*
* Cleans up entire line before returning to caller. A \n is appended.
* If line longer than screen, we redraw starting at beginning
*/
static void
gl_newline(
int w)
{
int change = gl_cnt;
int len = gl_cnt;
int loc = gl_width - 5; /* shifts line back to start position */
if (gl_cnt >= BUF_SIZE - 1) {
/*
* Like above: avoid crashing if possible. gl_addchar() now
* leaves one space left for the newline, so this part of the
* code should never be reached. A proper implementation is
* desirable though.
*/
error_message("tin_getline: input buffer overflow");
giveup();
}
hist_add(w); /* only adds if nonblank */
if (gl_out_hook) {
change = gl_out_hook(gl_buf);
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
len = wcslen(gl_buf);
#else
len = strlen(gl_buf);
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
}
if (loc > len)
loc = len;
gl_fixup(change, loc); /* must do this before appending \n */
#if defined(MULTIBYTE_ABLE) && !defined(NO_LOCALE)
gl_buf[len] = (wchar_t) '\0';
#else
gl_buf[len] = '\0';
#endif /* MULTIBYTE_ABLE && !NO_LOCALE */
}
/*
* Delete a character. The loc variable can be:
* -1 : delete character to left of cursor
* 0 : delete character under cursor
*/
static void
gl_del(
int loc)
{
int i;
if ((loc == -1 && gl_pos > 0) || (loc == 0 && gl_pos < gl_cnt)) {
for (i = gl_pos + loc; i < gl_cnt; i++)
gl_buf[i] = gl_buf[i + 1];
gl_fixup(gl_pos + loc, gl_pos + loc);
} else
ring_bell();
}