curs_lib.c

Go to the documentation of this file.

 
#include "config.h"
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <wchar.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "mutt.h"
#include "curs_lib.h"
#include "browser/lib.h"
#include "color/lib.h"
#include "enter/lib.h"
#include "question/lib.h"
#include "globals.h"
#include "keymap.h"
#include "msgwin.h"
#include "mutt_curses.h"
#include "mutt_logging.h"
#include "mutt_thread.h"
#include "mutt_window.h"
#include "opcodes.h"
#include "protos.h"
#ifdef HAVE_ISWBLANK
#include <wctype.h>
#endif
#ifdef USE_INOTIFY
#include "monitor.h"
#endif
 
/* not possible to unget more than one char under some curses libs, so roll our
 * own input buffering routines.  */
 
ARRAY_HEAD(KeyEventArray, struct KeyEvent);
 
static struct KeyEventArray MacroEvents = ARRAY_HEAD_INITIALIZER;
 
static struct KeyEventArray UngetKeyEvents = ARRAY_HEAD_INITIALIZER;
 
static struct KeyEvent *array_pop(struct KeyEventArray *a)
{
  if (ARRAY_EMPTY(a))
  {
    return NULL;
  }
 
  struct KeyEvent *event = ARRAY_LAST(a);
  ARRAY_SHRINK(a, 1);
  return event;
}
 
static void array_add(struct KeyEventArray *a, int ch, int op)
{
  struct KeyEvent event = { .ch = ch, .op = op };
  ARRAY_ADD(a, event);
}
 
static void array_to_endcond(struct KeyEventArray *a)
{
  while (!ARRAY_EMPTY(a))
  {
    if (array_pop(a)->op == OP_END_COND)
    {
      return;
    }
  }
}
 
int MuttGetchTimeout = -1;
 
void mutt_beep(bool force)
{
  const bool c_beep = cs_subset_bool(NeoMutt->sub, "beep");
  if (force || c_beep)
    beep();
}
 
void mutt_refresh(void)
{
  /* don't refresh when we are waiting for a child. */
  if (OptKeepQuiet)
    return;
 
  /* don't refresh in the middle of macros unless necessary */
  if (!ARRAY_EMPTY(&MacroEvents) && !OptForceRefresh && !OptIgnoreMacroEvents)
    return;
 
  /* else */
  refresh();
}
 
void mutt_need_hard_redraw(void)
{
  // Forcibly switch to the alternate screen.
  // Using encryption can leave ncurses confused about which mode it's in.
  fputs("\033[?1049h", stdout);
  fflush(stdout);
  keypad(stdscr, true);
  clearok(stdscr, true);
  window_redraw(NULL);
}
 
static void set_timeout(int delay)
{
  MuttGetchTimeout = delay;
  timeout(delay);
}
 
struct KeyEvent mutt_getch_timeout(int delay)
{
  set_timeout(delay);
  struct KeyEvent event = mutt_getch();
  set_timeout(-1);
  return event;
}
 
#ifdef USE_INOTIFY
static int mutt_monitor_getch(void)
{
  /* ncurses has its own internal buffer, so before we perform a poll,
   * we need to make sure there isn't a character waiting */
  timeout(0);
  int ch = getch();
  timeout(MuttGetchTimeout);
  if (ch == ERR)
  {
    if (mutt_monitor_poll() != 0)
      ch = ERR;
    else
      ch = getch();
  }
  return ch;
}
#endif /* USE_INOTIFY */
 
struct KeyEvent mutt_getch(void)
{
  int ch;
  const struct KeyEvent err = { 0, OP_ABORT };
  const struct KeyEvent timeout = { 0, OP_TIMEOUT };
 
  struct KeyEvent *key = array_pop(&UngetKeyEvents);
  if (key)
  {
    return *key;
  }
 
  if (!OptIgnoreMacroEvents && (key = array_pop(&MacroEvents)))
  {
    return *key;
  }
 
  SigInt = false;
 
  mutt_sig_allow_interrupt(true);
#ifdef KEY_RESIZE
  /* ncurses 4.2 sends this when the screen is resized */
  ch = KEY_RESIZE;
  while (ch == KEY_RESIZE)
#endif
#ifdef USE_INOTIFY
    ch = mutt_monitor_getch();
#else
  ch = getch();
#endif
  mutt_sig_allow_interrupt(false);
 
  if (SigInt)
  {
    mutt_query_exit();
    return err;
  }
 
  /* either timeout, a sigwinch (if timeout is set), the terminal
   * has been lost, or curses was never initialized */
  if (ch == ERR)
  {
    if (!isatty(0))
    {
      mutt_exit(1);
    }
 
    return OptNoCurses ? err : timeout;
  }
 
  const bool c_meta_key = cs_subset_bool(NeoMutt->sub, "meta_key");
  if ((ch & 0x80) && c_meta_key)
  {
    /* send ALT-x as ESC-x */
    ch &= ~0x80;
    mutt_unget_ch(ch);
    return (struct KeyEvent){ .ch = '\033' /* Escape */, .op = OP_NULL };
  }
 
  if (ch == AbortKey)
    return err;
 
  return (struct KeyEvent){ .ch = ch, .op = OP_NULL };
}
 
void mutt_edit_file(const char *editor, const char *file)
{
  struct Buffer *cmd = buf_pool_get();
 
  mutt_endwin();
  buf_file_expand_fmt_quote(cmd, editor, file);
  if (mutt_system(buf_string(cmd)) != 0)
  {
    mutt_error(_("Error running \"%s\""), buf_string(cmd));
  }
  /* the terminal may have been resized while the editor owned it */
  mutt_resize_screen();
  keypad(stdscr, true);
  clearok(stdscr, true);
 
  buf_pool_release(&cmd);
}
 
void mutt_query_exit(void)
{
  mutt_flushinp();
  enum MuttCursorState cursor = mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
  const short c_timeout = cs_subset_number(NeoMutt->sub, "timeout");
  if (c_timeout)
    set_timeout(-1); /* restore blocking operation */
  if (mutt_yesorno(_("Exit NeoMutt without saving?"), MUTT_YES) == MUTT_YES)
  {
    mutt_exit(0); /* This call never returns */
  }
  mutt_clear_error();
  mutt_curses_set_cursor(cursor);
  SigInt = false;
}
 
void mutt_endwin(void)
{
  if (OptNoCurses)
    return;
 
  int e = errno;
 
  /* at least in some situations (screen + xterm under SuSE11/12) endwin()
   * doesn't properly flush the screen without an explicit call.  */
  mutt_refresh();
  endwin();
 
  errno = e;
}
 
void mutt_perror_debug(const char *s)
{
  char *p = strerror(errno);
 
  mutt_debug(LL_DEBUG1, "%s: %s (errno = %d)\n", s, p ? p : "unknown error", errno);
  mutt_error("%s: %s (errno = %d)", s, p ? p : _("unknown error"), errno);
}
 
int mutt_any_key_to_continue(const char *s)
{
  struct termios term;
  struct termios old;
 
  int fd = open("/dev/tty", O_RDONLY);
  if (fd < 0)
    return EOF;
 
  tcgetattr(fd, &old); // Save the current tty settings
 
  term = old;
  term.c_lflag &= ~(ICANON | ECHO); // Canonical (not line-buffered), don't echo the characters
  term.c_cc[VMIN] = 1;    // Wait for at least one character
  term.c_cc[VTIME] = 255; // Wait for 25.5s
  tcsetattr(fd, TCSANOW, &term);
 
  if (s)
    fputs(s, stdout);
  else
    fputs(_("Press any key to continue..."), stdout);
  fflush(stdout);
 
  char ch = '\0';
  // Wait for a character.  This might timeout, so loop.
  while (read(fd, &ch, 1) == 0)
    ; // do nothing
 
  // Change the tty settings to be non-blocking
  term.c_cc[VMIN] = 0;  // Returning with zero characters is acceptable
  term.c_cc[VTIME] = 0; // Don't wait
  tcsetattr(fd, TCSANOW, &term);
 
  char buf[64] = { 0 };
  while (read(fd, buf, sizeof(buf)) > 0)
    ; // Mop up any remaining chars
 
  tcsetattr(fd, TCSANOW, &old); // Restore the previous tty settings
  close(fd);
 
  fputs("\r\n", stdout);
  mutt_clear_error();
  return (ch >= 0) ? ch : EOF;
}
 
int buf_enter_fname(const char *prompt, struct Buffer *fname, bool mailbox,
                    struct Mailbox *m, bool multiple, char ***files,
                    int *numfiles, SelectFileFlags flags)
{
  struct MuttWindow *win = msgwin_get_window();
  if (!win)
    return -1;
 
  struct KeyEvent ch = { OP_NULL, OP_NULL };
  struct MuttWindow *old_focus = window_set_focus(win);
 
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_PROMPT);
  mutt_window_mvaddstr(win, 0, 0, prompt);
  mutt_window_addstr(win, _(" ('?' for list): "));
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
  if (!buf_is_empty(fname))
    mutt_window_addstr(win, buf_string(fname));
  mutt_window_clrtoeol(win);
  mutt_refresh();
 
  enum MuttCursorState cursor = mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
  do
  {
    ch = mutt_getch();
  } while (ch.op == OP_TIMEOUT);
  mutt_curses_set_cursor(cursor);
 
  mutt_window_move(win, 0, 0);
  mutt_window_clrtoeol(win);
  mutt_refresh();
  window_set_focus(old_focus);
 
  if (ch.ch < 0)
  {
    return -1;
  }
  else if (ch.ch == '?')
  {
    buf_reset(fname);
 
    if (flags == MUTT_SEL_NO_FLAGS)
      flags = MUTT_SEL_FOLDER;
    if (multiple)
      flags |= MUTT_SEL_MULTI;
    if (mailbox)
      flags |= MUTT_SEL_MAILBOX;
    buf_select_file(fname, flags, m, files, numfiles);
  }
  else
  {
    char *pc = mutt_mem_malloc(mutt_str_len(prompt) + 3);
 
    sprintf(pc, "%s: ", prompt);
    if (ch.op == OP_NULL)
      mutt_unget_ch(ch.ch);
    else
      mutt_unget_op(ch.op);
 
    buf_alloc(fname, 1024);
    if (buf_get_field(pc, fname, (mailbox ? MUTT_COMP_FILE_MBOX : MUTT_COMP_FILE) | MUTT_COMP_CLEAR,
                      multiple, m, files, numfiles) != 0)
    {
      buf_reset(fname);
    }
    FREE(&pc);
  }
 
  return 0;
}
 
void mutt_unget_ch(int ch)
{
  array_add(&UngetKeyEvents, ch, OP_NULL);
}
 
void mutt_unget_op(int op)
{
  array_add(&UngetKeyEvents, 0, op);
}
 
void mutt_unget_string(const char *s)
{
  const char *p = s + mutt_str_len(s) - 1;
 
  while (p >= s)
  {
    mutt_unget_ch((unsigned char) *p--);
  }
}
 
void mutt_push_macro_event(int ch, int op)
{
  array_add(&MacroEvents, ch, op);
}
 
void mutt_flush_macro_to_endcond(void)
{
  array_to_endcond(&MacroEvents);
}
 
void mutt_flush_unget_to_endcond(void)
{
  array_to_endcond(&UngetKeyEvents);
}
 
void mutt_flushinp(void)
{
  ARRAY_SHRINK(&UngetKeyEvents, ARRAY_SIZE(&UngetKeyEvents));
  ARRAY_SHRINK(&MacroEvents, ARRAY_SIZE(&MacroEvents));
  flushinp();
}
 
int mutt_addwch(struct MuttWindow *win, wchar_t wc)
{
  char buf[MB_LEN_MAX * 2];
  mbstate_t mbstate = { 0 };
  size_t n1, n2;
 
  if (((n1 = wcrtomb(buf, wc, &mbstate)) == ICONV_ILLEGAL_SEQ) ||
      ((n2 = wcrtomb(buf + n1, 0, &mbstate)) == ICONV_ILLEGAL_SEQ))
  {
    return -1; /* ERR */
  }
  else
  {
    return mutt_window_addstr(win, buf);
  }
}
 
void mutt_simple_format(char *buf, size_t buflen, int min_width, int max_width,
                        enum FormatJustify justify, char pad_char,
                        const char *s, size_t n, bool arboreal)
{
  wchar_t wc = 0;
  int w;
  size_t k;
  char scratch[MB_LEN_MAX] = { 0 };
  mbstate_t mbstate1 = { 0 };
  mbstate_t mbstate2 = { 0 };
  bool escaped = false;
 
  buflen--;
  char *p = buf;
  for (; n && (k = mbrtowc(&wc, s, n, &mbstate1)); s += k, n -= k)
  {
    if ((k == ICONV_ILLEGAL_SEQ) || (k == ICONV_BUF_TOO_SMALL))
    {
      if ((k == ICONV_ILLEGAL_SEQ) && (errno == EILSEQ))
        memset(&mbstate1, 0, sizeof(mbstate1));
 
      k = (k == ICONV_ILLEGAL_SEQ) ? 1 : n;
      wc = ReplacementChar;
    }
    if (escaped)
    {
      escaped = false;
      w = 0;
    }
    else if (arboreal && (wc == MUTT_SPECIAL_INDEX))
    {
      escaped = true;
      w = 0;
    }
    else if (arboreal && (wc < MUTT_TREE_MAX))
    {
      w = 1; /* hack */
    }
    else
    {
#ifdef HAVE_ISWBLANK
      if (iswblank(wc))
        wc = ' ';
      else
#endif
          if (!IsWPrint(wc))
        wc = '?';
      w = wcwidth(wc);
    }
    if (w >= 0)
    {
      if (w > max_width)
        continue;
      size_t k2 = wcrtomb(scratch, wc, &mbstate2);
      if ((k2 == ICONV_ILLEGAL_SEQ) || (k2 > buflen))
        continue;
 
      min_width -= w;
      max_width -= w;
      strncpy(p, scratch, k2);
      p += k2;
      buflen -= k2;
    }
  }
  w = ((int) buflen < min_width) ? buflen : min_width;
  if (w <= 0)
  {
    *p = '\0';
  }
  else if (justify == JUSTIFY_RIGHT) /* right justify */
  {
    p[w] = '\0';
    while (--p >= buf)
      p[w] = *p;
    while (--w >= 0)
      buf[w] = pad_char;
  }
  else if (justify == JUSTIFY_CENTER) /* center */
  {
    char *savedp = p;
    int half = (w + 1) / 2; /* half of cushion space */
 
    p[w] = '\0';
 
    /* move str to center of buffer */
    while (--p >= buf)
      p[half] = *p;
 
    /* fill rhs */
    p = savedp + half;
    while (--w >= half)
      *p++ = pad_char;
 
    /* fill lhs */
    while (half--)
      buf[half] = pad_char;
  }
  else /* left justify */
  {
    while (--w >= 0)
      *p++ = pad_char;
    *p = '\0';
  }
}
 
void mutt_format_s_x(char *buf, size_t buflen, const char *prec, const char *s, bool arboreal)
{
  enum FormatJustify justify = JUSTIFY_RIGHT;
  char *p = NULL;
  int min_width;
  int max_width = INT_MAX;
 
  if (*prec == '-')
  {
    prec++;
    justify = JUSTIFY_LEFT;
  }
  else if (*prec == '=')
  {
    prec++;
    justify = JUSTIFY_CENTER;
  }
  min_width = strtol(prec, &p, 10);
  if (*p == '.')
  {
    prec = p + 1;
    max_width = strtol(prec, &p, 10);
    if (p <= prec)
      max_width = INT_MAX;
  }
 
  mutt_simple_format(buf, buflen, min_width, max_width, justify, ' ', s,
                     mutt_str_len(s), arboreal);
}
 
void mutt_format_s(char *buf, size_t buflen, const char *prec, const char *s)
{
  mutt_format_s_x(buf, buflen, prec, s, false);
}
 
void mutt_format_s_tree(char *buf, size_t buflen, const char *prec, const char *s)
{
  mutt_format_s_x(buf, buflen, prec, s, true);
}
 
void mutt_paddstr(struct MuttWindow *win, int n, const char *s)
{
  wchar_t wc = 0;
  size_t k;
  size_t len = mutt_str_len(s);
  mbstate_t mbstate = { 0 };
 
  for (; len && (k = mbrtowc(&wc, s, len, &mbstate)); s += k, len -= k)
  {
    if ((k == ICONV_ILLEGAL_SEQ) || (k == ICONV_BUF_TOO_SMALL))
    {
      if (k == ICONV_ILLEGAL_SEQ)
        memset(&mbstate, 0, sizeof(mbstate));
      k = (k == ICONV_ILLEGAL_SEQ) ? 1 : len;
      wc = ReplacementChar;
    }
    if (!IsWPrint(wc))
      wc = '?';
    const int w = wcwidth(wc);
    if (w >= 0)
    {
      if (w > n)
        break;
      mutt_window_addnstr(win, (char *) s, k);
      n -= w;
    }
  }
  while (n-- > 0)
    mutt_window_addch(win, ' ');
}
 
size_t mutt_wstr_trunc(const char *src, size_t maxlen, size_t maxwid, size_t *width)
{
  wchar_t wc = 0;
  size_t n, w = 0, l = 0, cl;
  int cw;
  mbstate_t mbstate = { 0 };
 
  if (!src)
    goto out;
 
  n = mutt_str_len(src);
 
  for (w = 0; n && (cl = mbrtowc(&wc, src, n, &mbstate)); src += cl, n -= cl)
  {
    if ((cl == ICONV_ILLEGAL_SEQ) || (cl == ICONV_BUF_TOO_SMALL))
    {
      if (cl == ICONV_ILLEGAL_SEQ)
        memset(&mbstate, 0, sizeof(mbstate));
      cl = (cl == ICONV_ILLEGAL_SEQ) ? 1 : n;
      wc = ReplacementChar;
    }
    cw = wcwidth(wc);
    /* hack because MUTT_TREE symbols aren't turned into characters
     * until rendered by print_enriched_string() */
    if ((cw < 0) && (src[0] == MUTT_SPECIAL_INDEX))
    {
      cl = 2; /* skip the index coloring sequence */
      cw = 0;
    }
    else if ((cw < 0) && (cl == 1) && (src[0] != '\0') && (src[0] < MUTT_TREE_MAX))
    {
      cw = 1;
    }
    else if (cw < 0)
    {
      cw = 0; /* unprintable wchar */
    }
    if ((cl + l > maxlen) || (cw + w > maxwid))
      break;
    l += cl;
    w += cw;
  }
out:
  if (width)
    *width = w;
  return l;
}
 
size_t mutt_strwidth(const char *s)
{
  if (!s)
    return 0;
  return mutt_strnwidth(s, mutt_str_len(s));
}
 
size_t mutt_strnwidth(const char *s, size_t n)
{
  if (!s)
    return 0;
 
  wchar_t wc = 0;
  int w;
  size_t k;
  mbstate_t mbstate = { 0 };
 
  for (w = 0; n && (k = mbrtowc(&wc, s, n, &mbstate)); s += k, n -= k)
  {
    if (*s == MUTT_SPECIAL_INDEX)
    {
      s += 2; /* skip the index coloring sequence */
      k = 0;
      continue;
    }
 
    if ((k == ICONV_ILLEGAL_SEQ) || (k == ICONV_BUF_TOO_SMALL))
    {
      if (k == ICONV_ILLEGAL_SEQ)
        memset(&mbstate, 0, sizeof(mbstate));
      k = (k == ICONV_ILLEGAL_SEQ) ? 1 : n;
      wc = ReplacementChar;
    }
    if (!IsWPrint(wc))
      wc = '?';
    w += wcwidth(wc);
  }
  return w;
}