curs_lib.h File Reference

GUI miscellaneous curses (window drawing) routines. More...

#include <stddef.h>
#include <stdbool.h>
#include <wchar.h>
#include "config/lib.h"
#include "mutt.h"
#include "browser.h"
#include "keymap.h"
#include "pager.h"

Include dependency graph for curs_lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	mutt_buffer_get_field(field, buf, complete)   mutt_buffer_get_field_full(field, buf, complete, false, NULL, NULL)
#define	mutt_buffer_enter_fname(prompt, fname, mailbox)   mutt_buffer_enter_fname_full(prompt, fname, mailbox, false, NULL, NULL, MUTT_SEL_NO_FLAGS)
#define	mutt_get_field(field, buf, buflen, complete)   mutt_get_field_full(field, buf, buflen, complete, false, NULL, NULL)
#define	mutt_get_password(msg, buf, buflen)   mutt_get_field_unbuffered(msg, buf, buflen, MUTT_PASS)

Enumerations
enum	FormatJustify { JUSTIFY_LEFT = -1, JUSTIFY_CENTER = 0, JUSTIFY_RIGHT = 1 }
	Alignment for mutt_simple_format() More...

Functions
int	mutt_addwch (wchar_t wc)
	addwch would be provided by an up-to-date curses library More...
int	mutt_any_key_to_continue (const char *s)
	Prompt the user to 'press any key' and wait. More...
void	mutt_beep (bool force)
	Irritate the user. More...
int	mutt_do_pager (const char *banner, const char *tempfile, PagerFlags do_color, struct Pager *info)
	Display some page-able text to the user. More...
void	mutt_edit_file (const char *editor, const char *file)
	Let the user edit a file. More...
void	mutt_endwin (void)
	Shutdown curses/slang. More...
void	mutt_flushinp (void)
	Empty all the keyboard buffers. More...
void	mutt_flush_macro_to_endcond (void)
	Drop a macro from the input buffer. More...
void	mutt_flush_unget_to_endcond (void)
	Clear entries from UngetKeyEvents. More...
void	mutt_format_s (char *buf, size_t buflen, const char *prec, const char *s)
	Format a simple string. More...
void	mutt_format_s_tree (char *buf, size_t buflen, const char *prec, const char *s)
	Format a simple string with tree characters. More...
void	mutt_format_s_x (char *buf, size_t buflen, const char *prec, const char *s, bool arboreal)
	Format a string like snprintf() More...
void	mutt_getch_timeout (int delay)
	Set the getch() timeout. More...
struct KeyEvent	mutt_getch (void)
	Read a character from the input buffer. More...
int	mutt_get_field_full (const char *field, char *buf, size_t buflen, CompletionFlags complete, bool multiple, char ***files, int *numfiles)
	Ask the user for a string. More...
int	mutt_get_field_unbuffered (const char *msg, char *buf, size_t buflen, CompletionFlags flags)
	Ask the user for a string (ignoring macro buffer) More...
int	mutt_multi_choice (const char *prompt, const char *letters)
	Offer the user a multiple choice question. More...
void	mutt_need_hard_redraw (void)
	Force a hard refresh. More...
void	mutt_paddstr (int n, const char *s)
	Display a string on screen, padded if necessary. More...
void	mutt_perror_debug (const char *s)
	Show the user an 'errno' message. More...
void	mutt_push_macro_event (int ch, int op)
	Add the character/operation to the macro buffer. More...
void	mutt_query_exit (void)
	Ask the user if they want to leave NeoMutt. More...
void	mutt_refresh (void)
	Force a refresh of the screen. More...
void	mutt_show_error (void)
	Show the user an error message. More...
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)
	Format a string, like snprintf() More...
int	mutt_strwidth (const char *s)
	Measure a string's width in screen cells. More...
int	mutt_strnwidth (const char *s, size_t len)
	Measure a string's width in screen cells. More...
void	mutt_unget_event (int ch, int op)
	Return a keystroke to the input buffer. More...
void	mutt_unget_string (const char *s)
	Return a string to the input buffer. More...
size_t	mutt_wstr_trunc (const char *src, size_t maxlen, size_t maxwid, size_t *width)
	Work out how to truncate a widechar string. More...
enum QuadOption	mutt_yesorno (const char *msg, enum QuadOption def)
	Ask the user a Yes/No question. More...
enum QuadOption	query_quadoption (enum QuadOption opt, const char *prompt)
	Ask the user a quad-question. More...
int	mutt_buffer_get_field_full (const char *field, struct Buffer *buf, CompletionFlags complete, bool multiple, char ***files, int *numfiles)
	Ask the user for a string. More...
int	mutt_buffer_enter_fname_full (const char *prompt, struct Buffer *fname, bool mailbox, bool multiple, char ***files, int *numfiles, SelectFileFlags flags)
	Ask the user to select a file. More...

Variables
bool	C_MetaKey
	interpret ALT-x as ESC-x More...
int	MuttGetchTimeout
	Timeout in ms for mutt_getch() More...

Detailed Description

GUI miscellaneous curses (window drawing) routines.

Authors

• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file curs_lib.h.

Macro Definition Documentation

mutt_buffer_get_field

#define mutt_buffer_get_field	(		field,
			buf,
			complete
	)		mutt_buffer_get_field_full(field, buf, complete, false, NULL, NULL)

Definition at line 85 of file curs_lib.h.

mutt_buffer_enter_fname

#define mutt_buffer_enter_fname	(		prompt,
			fname,
			mailbox
	)		mutt_buffer_enter_fname_full(prompt, fname, mailbox, false, NULL, NULL, MUTT_SEL_NO_FLAGS)

Definition at line 88 of file curs_lib.h.

mutt_get_field

#define mutt_get_field	(		field,
			buf,
			buflen,
			complete
	)		mutt_get_field_full(field, buf, buflen, complete, false, NULL, NULL)

Definition at line 91 of file curs_lib.h.

mutt_get_password

#define mutt_get_password	(		msg,
			buf,
			buflen
	)		mutt_get_field_unbuffered(msg, buf, buflen, MUTT_PASS)

Definition at line 92 of file curs_lib.h.

Enumeration Type Documentation

FormatJustify

enum FormatJustify

Alignment for mutt_simple_format()

Enumerator
JUSTIFY_LEFT	Left justify the text.
JUSTIFY_CENTER	Centre the text.
JUSTIFY_RIGHT	Right justify the text.

Definition at line 45 of file curs_lib.h.

{
  JUSTIFY_LEFT = -1,  
  JUSTIFY_CENTER = 0, 
  JUSTIFY_RIGHT = 1,  
};

Function Documentation

mutt_addwch()

int mutt_addwch

(

wchar_t

wc

)

addwch would be provided by an up-to-date curses library

Parameters

wc	Wide char to display

Return values

0	Success
-1	Error

Definition at line 1058 of file curs_lib.c.

{
  char buf[MB_LEN_MAX * 2];
  mbstate_t mbstate;
  size_t n1, n2;

  memset(&mbstate, 0, sizeof(mbstate));
  if (((n1 = wcrtomb(buf, wc, &mbstate)) == (size_t)(-1)) ||
      ((n2 = wcrtomb(buf + n1, 0, &mbstate)) == (size_t)(-1)))
  {
    return -1; /* ERR */
  }
  else
  {
    return mutt_window_addstr(buf);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_any_key_to_continue()

int mutt_any_key_to_continue

(

const char *

s

)

Prompt the user to 'press any key' and wait.

Parameters

s	Message prompt

Return values

num	Key pressed
EOF	Error, or prompt aborted

Definition at line 603 of file curs_lib.c.

{
  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];
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_beep()

void mutt_beep

(

bool

force

)

Irritate the user.

Parameters

force

If true, ignore the "$beep" config variable

Definition at line 98 of file curs_lib.c.

{
  if (force || C_Beep)
    beep();
}

Here is the caller graph for this function:

mutt_do_pager()

int mutt_do_pager	(	const char *	banner,
		const char *	tempfile,
		PagerFlags	do_color,
		struct Pager *	info
	)

Display some page-able text to the user.

Parameters

banner	Message for status bar
tempfile	File to display
do_color	Flags, see PagerFlags
info	Info about current mailbox (OPTIONAL)

Return values

0	Success
-1	Error

Definition at line 689 of file curs_lib.c.

{
  struct Pager info2 = { 0 };
  if (!info)
    info = &info2;

  struct MuttWindow *dlg =
      mutt_window_new(WT_DLG_DO_PAGER, MUTT_WIN_ORIENT_VERTICAL, MUTT_WIN_SIZE_MAXIMISE,
                      MUTT_WIN_SIZE_UNLIMITED, MUTT_WIN_SIZE_UNLIMITED);

  struct MuttWindow *pager =
      mutt_window_new(WT_PAGER, MUTT_WIN_ORIENT_VERTICAL, MUTT_WIN_SIZE_MAXIMISE,
                      MUTT_WIN_SIZE_UNLIMITED, MUTT_WIN_SIZE_UNLIMITED);
  dlg->focus = pager;

  struct MuttWindow *pbar =
      mutt_window_new(WT_PAGER_BAR, MUTT_WIN_ORIENT_VERTICAL,
                      MUTT_WIN_SIZE_FIXED, MUTT_WIN_SIZE_UNLIMITED, 1);

  if (C_StatusOnTop)
  {
    mutt_window_add_child(dlg, pbar);
    mutt_window_add_child(dlg, pager);
  }
  else
  {
    mutt_window_add_child(dlg, pager);
    mutt_window_add_child(dlg, pbar);
  }

  notify_observer_add(NeoMutt->notify, mutt_dlg_dopager_observer, dlg);
  dialog_push(dlg);

  info->win_ibar = NULL;
  info->win_index = NULL;
  info->win_pbar = pbar;
  info->win_pager = pager;

  int rc;

  if (!C_Pager || mutt_str_equal(C_Pager, "builtin"))
    rc = mutt_pager(banner, tempfile, do_color, info);
  else
  {
    struct Buffer *cmd = mutt_buffer_pool_get();

    mutt_endwin();
    mutt_buffer_file_expand_fmt_quote(cmd, C_Pager, tempfile);
    if (mutt_system(mutt_b2s(cmd)) == -1)
    {
      mutt_error(_("Error running \"%s\""), mutt_b2s(cmd));
      rc = -1;
    }
    else
      rc = 0;
    mutt_file_unlink(tempfile);
    mutt_buffer_pool_release(&cmd);
  }

  dialog_pop();
  notify_observer_remove(NeoMutt->notify, mutt_dlg_dopager_observer, dlg);
  mutt_window_free(&dlg);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_edit_file()

void mutt_edit_file	(	const char *	editor,
		const char *	file
	)

Let the user edit a file.

Parameters

editor	User's editor config
file	File to edit

Definition at line 354 of file curs_lib.c.

{
  struct Buffer *cmd = mutt_buffer_pool_get();

  mutt_endwin();
  mutt_buffer_file_expand_fmt_quote(cmd, editor, file);
  if (mutt_system(mutt_b2s(cmd)) != 0)
  {
    mutt_error(_("Error running \"%s\""), mutt_b2s(cmd));
  }
  /* the terminal may have been resized while the editor owned it */
  mutt_resize_screen();
  keypad(stdscr, true);
  clearok(stdscr, true);

  mutt_buffer_pool_release(&cmd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_endwin()

void mutt_endwin

(

void

)

Shutdown curses/slang.

Definition at line 570 of file curs_lib.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_flushinp()

void mutt_flushinp

(

void

)

Empty all the keyboard buffers.

Definition at line 918 of file curs_lib.c.

{
  UngetCount = 0;
  MacroBufferCount = 0;
  flushinp();
}

Here is the caller graph for this function:

mutt_flush_macro_to_endcond()

void mutt_flush_macro_to_endcond

(

void

)

Drop a macro from the input buffer.

All the macro text is deleted until an OP_END_COND command, or the buffer is empty.

Definition at line 889 of file curs_lib.c.

{
  UngetCount = 0;
  while (MacroBufferCount > 0)
  {
    if (MacroEvents[--MacroBufferCount].op == OP_END_COND)
      return;
  }
}

Here is the caller graph for this function:

mutt_flush_unget_to_endcond()

void mutt_flush_unget_to_endcond

(

void

)

Clear entries from UngetKeyEvents.

Normally, OP_END_COND should only be in the MacroEvent buffer. km_error_key() (ab)uses OP_END_COND as a barrier in the unget buffer, and calls this function to flush.

Definition at line 906 of file curs_lib.c.

{
  while (UngetCount > 0)
  {
    if (UngetKeyEvents[--UngetCount].op == OP_END_COND)
      return;
  }
}

Here is the caller graph for this function:

mutt_format_s()

void mutt_format_s	(	char *	buf,
		size_t	buflen,
		const char *	prec,
		const char *	s
	)

Format a simple string.

Parameters

[out]	buf	Buffer in which to save string
[in]	buflen	Buffer length
[in]	prec	Field precision, e.g. "-3.4"
[in]	s	String to format

Definition at line 1243 of file curs_lib.c.

{
  mutt_format_s_x(buf, buflen, prec, s, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_format_s_tree()

void mutt_format_s_tree	(	char *	buf,
		size_t	buflen,
		const char *	prec,
		const char *	s
	)

Format a simple string with tree characters.

Parameters

[out]	buf	Buffer in which to save string
[in]	buflen	Buffer length
[in]	prec	Field precision, e.g. "-3.4"
[in]	s	String to format

Definition at line 1255 of file curs_lib.c.

{
  mutt_format_s_x(buf, buflen, prec, s, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_format_s_x()

void mutt_format_s_x	(	char *	buf,
		size_t	buflen,
		const char *	prec,
		const char *	s,
		bool	arboreal
	)

Format a string like snprintf()

Parameters

[out]	buf	Buffer in which to save string
[in]	buflen	Buffer length
[in]	prec	Field precision, e.g. "-3.4"
[in]	s	String to format
[in]	arboreal	If true, string contains graphical tree characters

This formats a string rather like:

• snprintf(fmt, sizeof(fmt), "%%%ss", prec);
• snprintf(buf, buflen, fmt, s); except that the numbers in the conversion specification refer to the number of character cells when printed.

Definition at line 1206 of file curs_lib.c.

{
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_getch_timeout()

void mutt_getch_timeout

(

int

delay

)

Set the getch() timeout.

Parameters

delay

Timeout delay in ms

delay is just like for timeout() or poll(): the number of milliseconds mutt_getch() should block for input.

• delay == 0 means mutt_getch() is non-blocking.
• delay < 0 means mutt_getch is blocking.

Definition at line 145 of file curs_lib.c.

{
  MuttGetchTimeout = delay;
  timeout(delay);
}

Here is the caller graph for this function:

mutt_getch()

struct KeyEvent mutt_getch

(

void

)

Read a character from the input buffer.

Return values

obj	KeyEvent to process

The priority for reading events is:

1. UngetKeyEvents buffer
2. MacroEvents buffer
3. Keyboard

This function can return:

• Error { -1, OP_NULL }
• Timeout { -2, OP_NULL }

Definition at line 188 of file curs_lib.c.

{
  int ch;
  struct KeyEvent err = { -1, OP_NULL }, ret;
  struct KeyEvent timeout = { -2, OP_NULL };

  if (UngetCount)
    return UngetKeyEvents[--UngetCount];

  if (!OptIgnoreMacroEvents && MacroBufferCount)
    return MacroEvents[--MacroBufferCount];

  SigInt = 0;

  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 /* KEY_RESIZE */
#ifdef USE_INOTIFY
    ch = mutt_monitor_getch();
#else
  ch = getch();
#endif /* USE_INOTIFY */
  mutt_sig_allow_interrupt(false);

  if (SigInt)
  {
    mutt_query_exit();
    return err;
  }

  /* either timeout, a sigwinch (if timeout is set), or the terminal
   * has been lost */
  if (ch == ERR)
  {
    if (!isatty(0))
      mutt_exit(1);

    return timeout;
  }

  if ((ch & 0x80) && C_MetaKey)
  {
    /* send ALT-x as ESC-x */
    ch &= ~0x80;
    mutt_unget_event(ch, 0);
    ret.ch = '\033'; // Escape
    ret.op = 0;
    return ret;
  }

  ret.ch = ch;
  ret.op = 0;
  return (ch == AbortKey) ? err : ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_field_full()

int mutt_get_field_full	(	const char *	field,
		char *	buf,
		size_t	buflen,
		CompletionFlags	complete,
		bool	multiple,
		char ***	files,
		int *	numfiles
	)

Ask the user for a string.

Parameters

[in]	field	Prompt
[in]	buf	Buffer for the result
[in]	buflen	Length of buffer
[in]	complete	Flags, see CompletionFlags
[in]	multiple	Allow multiple selections
[out]	files	List of files selected
[out]	numfiles	Number of files selected

Return values

1	Redraw the screen and call the function again
0	Selection made
-1	Aborted

Definition at line 309 of file curs_lib.c.

{
  if (!buf)
    return -1;

  struct Buffer tmp = {
    .data = buf,
    .dptr = buf + mutt_str_len(buf),
    .dsize = buflen,
  };
  return mutt_buffer_get_field_full(field, &tmp, complete, multiple, files, numfiles);
}

Here is the call graph for this function:

mutt_get_field_unbuffered()

int mutt_get_field_unbuffered	(	const char *	msg,
		char *	buf,
		size_t	buflen,
		CompletionFlags	flags
	)

Ask the user for a string (ignoring macro buffer)

Parameters

msg	Prompt
buf	Buffer for the result
buflen	Length of buffer
flags	Flags, see CompletionFlags

Return values

1	Redraw the screen and call the function again
0	Selection made
-1	Aborted

Definition at line 333 of file curs_lib.c.

{
  bool reset_ignoremacro = false;

  if (!OptIgnoreMacroEvents)
  {
    OptIgnoreMacroEvents = true;
    reset_ignoremacro = true;
  }
  int rc = mutt_get_field(msg, buf, buflen, flags);
  if (reset_ignoremacro)
    OptIgnoreMacroEvents = false;

  return rc;
}

Here is the caller graph for this function:

mutt_multi_choice()

int mutt_multi_choice	(	const char *	prompt,
		const char *	letters
	)

Offer the user a multiple choice question.

Parameters

prompt	Message prompt
letters	Allowable selection keys

Return values

>=0	0-based user selection
-1	Selection aborted

Definition at line 932 of file curs_lib.c.

{
  struct KeyEvent ch;
  int choice;
  bool redraw = true;
  int prompt_lines = 1;

  bool opt_cols = ((Colors->defs[MT_COLOR_OPTIONS] != 0) &&
                   (Colors->defs[MT_COLOR_OPTIONS] != Colors->defs[MT_COLOR_PROMPT]));

  while (true)
  {
    if (redraw || SigWinch)
    {
      redraw = false;
      if (SigWinch)
      {
        SigWinch = 0;
        mutt_resize_screen();
        clearok(stdscr, true);
        mutt_menu_current_redraw();
      }
      if (MessageWindow->state.cols)
      {
        int width = mutt_strwidth(prompt) + 2; // + '?' + space
        /* If we're going to colour the options,
         * make an assumption about the modified prompt size. */
        if (opt_cols)
          width -= 2 * mutt_str_len(letters);

        prompt_lines =
            (width + MessageWindow->state.cols - 1) / MessageWindow->state.cols;
        prompt_lines = MAX(1, MIN(3, prompt_lines));
      }
      if (prompt_lines != MessageWindow->state.rows)
      {
        mutt_window_reflow_message_rows(prompt_lines);
        mutt_menu_current_redraw();
      }

      mutt_window_move(MessageWindow, 0, 0);

      if ((Colors->defs[MT_COLOR_OPTIONS] != 0) &&
          (Colors->defs[MT_COLOR_OPTIONS] != Colors->defs[MT_COLOR_PROMPT]))
      {
        char *cur = NULL;

        while ((cur = strchr(prompt, '(')))
        {
          // write the part between prompt and cur using MT_COLOR_PROMPT
          mutt_curses_set_color(MT_COLOR_PROMPT);
          mutt_window_addnstr(prompt, cur - prompt);

          if (isalnum(cur[1]) && (cur[2] == ')'))
          {
            // we have a single letter within parentheses
            mutt_curses_set_color(MT_COLOR_OPTIONS);
            mutt_window_addch(cur[1]);
            prompt = cur + 3;
          }
          else
          {
            // we have a parenthesis followed by something else
            mutt_window_addch(cur[0]);
            prompt = cur + 1;
          }
        }
      }

      mutt_curses_set_color(MT_COLOR_PROMPT);
      mutt_window_addstr(prompt);
      mutt_curses_set_color(MT_COLOR_NORMAL);

      mutt_window_addch(' ');
      mutt_window_clrtoeol(MessageWindow);
    }

    mutt_refresh();
    /* SigWinch is not processed unless timeout is set */
    mutt_getch_timeout(30 * 1000);
    ch = mutt_getch();
    mutt_getch_timeout(-1);
    if (ch.ch == -2)
      continue;
    /* (ch.ch == 0) is technically possible.  Treat the same as < 0 (abort) */
    if ((ch.ch <= 0) || CI_is_return(ch.ch))
    {
      choice = -1;
      break;
    }
    else
    {
      char *p = strchr(letters, ch.ch);
      if (p)
      {
        choice = p - letters + 1;
        break;
      }
      else if ((ch.ch <= '9') && (ch.ch > '0'))
      {
        choice = ch.ch - '0';
        if (choice <= mutt_str_len(letters))
          break;
      }
    }
    mutt_beep(false);
  }
  if (MessageWindow->state.rows == 1)
  {
    mutt_window_clearline(MessageWindow, 0);
  }
  else
  {
    mutt_window_reflow_message_rows(1);
    mutt_menu_current_redraw();
  }
  mutt_refresh();
  return choice;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_need_hard_redraw()

void mutt_need_hard_redraw

(

void

)

Force a hard refresh.

Make sure that the next refresh does a full refresh. This could be optimized by not doing it at all if DISPLAY is set as this might indicate that a GUI based pinentry was used. Having an option to customize this is of course the NeoMutt way.

Definition at line 129 of file curs_lib.c.

{
  keypad(stdscr, true);
  clearok(stdscr, true);
  mutt_menu_set_current_redraw_full();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_paddstr()

void mutt_paddstr	(	int	n,
		const char *	s
	)

Display a string on screen, padded if necessary.

Parameters

n	Final width of field
s	String to display

Definition at line 1265 of file curs_lib.c.

{
  wchar_t wc;
  size_t k;
  size_t len = mutt_str_len(s);
  mbstate_t mbstate;

  memset(&mbstate, 0, sizeof(mbstate));
  for (; len && (k = mbrtowc(&wc, s, len, &mbstate)); s += k, len -= k)
  {
    if ((k == (size_t)(-1)) || (k == (size_t)(-2)))
    {
      if (k == (size_t)(-1))
        memset(&mbstate, 0, sizeof(mbstate));
      k = (k == (size_t)(-1)) ? 1 : len;
      wc = ReplacementChar;
    }
    if (!IsWPrint(wc))
      wc = '?';
    const int w = wcwidth(wc);
    if (w >= 0)
    {
      if (w > n)
        break;
      mutt_window_addnstr((char *) s, k);
      n -= w;
    }
  }
  while (n-- > 0)
    mutt_window_addch(' ');
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_perror_debug()

void mutt_perror_debug

(

const char *

s

)

Show the user an 'errno' message.

Parameters

s	Additional text to show

Definition at line 589 of file curs_lib.c.

{
  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);
}

mutt_push_macro_event()

void mutt_push_macro_event	(	int	ch,
		int	op
	)

Add the character/operation to the macro buffer.

Parameters

ch	Character to add
op	Operation to add

Adds the ch/op to the macro buffer. This should be used for macros, push, and exec commands only.

Definition at line 870 of file curs_lib.c.

{
  struct KeyEvent tmp;

  tmp.ch = ch;
  tmp.op = op;

  if (MacroBufferCount >= MacroBufferLen)
    mutt_mem_realloc(&MacroEvents, (MacroBufferLen += 128) * sizeof(struct KeyEvent));

  MacroEvents[MacroBufferCount++] = tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_query_exit()

void mutt_query_exit

(

void

)

Ask the user if they want to leave NeoMutt.

This function is called when the user presses the abort key.

Definition at line 538 of file curs_lib.c.

{
  mutt_flushinp();
  mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
  if (C_Timeout)
    mutt_getch_timeout(-1); /* restore blocking operation */
  if (mutt_yesorno(_("Exit NeoMutt?"), MUTT_YES) == MUTT_YES)
  {
    mutt_exit(1);
  }
  mutt_clear_error();
  mutt_curses_set_cursor(MUTT_CURSOR_RESTORE_LAST);
  SigInt = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_refresh()

void mutt_refresh

(

void

)

Force a refresh of the screen.

Definition at line 107 of file curs_lib.c.

{
  /* don't refresh when we are waiting for a child. */
  if (OptKeepQuiet)
    return;

  /* don't refresh in the middle of macros unless necessary */
  if (MacroBufferCount && !OptForceRefresh && !OptIgnoreMacroEvents)
    return;

  /* else */
  refresh();
}

Here is the caller graph for this function:

mutt_show_error()

void mutt_show_error

(

void

)

Show the user an error message.

Definition at line 556 of file curs_lib.c.

{
  if (OptKeepQuiet || !ErrorBufMessage)
    return;

  mutt_curses_set_color(OptMsgErr ? MT_COLOR_ERROR : MT_COLOR_MESSAGE);
  mutt_window_mvaddstr(MessageWindow, 0, 0, ErrorBuf);
  mutt_curses_set_color(MT_COLOR_NORMAL);
  mutt_window_clrtoeol(MessageWindow);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_simple_format()

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
	)

Format a string, like snprintf()

Parameters

[out]	buf	Buffer in which to save string
[in]	buflen	Buffer length
[in]	min_width	Minimum width
[in]	max_width	Maximum width
[in]	justify	Justification, e.g. JUSTIFY_RIGHT
[in]	pad_char	Padding character
[in]	s	String to format
[in]	n	Number of bytes of string to format
[in]	arboreal	If true, string contains graphical tree characters

This formats a string, a bit like snprintf(buf, buflen, "%-*.*s", min_width, max_width, s), except that the widths refer to the number of character cells when printed.

Definition at line 1092 of file curs_lib.c.

{
  wchar_t wc;
  int w;
  size_t k, k2;
  char scratch[MB_LEN_MAX];
  mbstate_t mbstate1, mbstate2;
  bool escaped = false;

  memset(&mbstate1, 0, sizeof(mbstate1));
  memset(&mbstate2, 0, sizeof(mbstate2));
  buflen--;
  char *p = buf;
  for (; n && (k = mbrtowc(&wc, s, n, &mbstate1)); s += k, n -= k)
  {
    if ((k == (size_t)(-1)) || (k == (size_t)(-2)))
    {
      if ((k == (size_t)(-1)) && (errno == EILSEQ))
        memset(&mbstate1, 0, sizeof(mbstate1));

      k = (k == (size_t)(-1)) ? 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) || ((k2 = wcrtomb(scratch, wc, &mbstate2)) > 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';
  }
}

Here is the caller graph for this function:

mutt_strwidth()

int mutt_strwidth

(

const char *

s

)

Measure a string's width in screen cells.

Parameters

s	String to be measured

Return values

num	Screen cells string would use

Definition at line 1358 of file curs_lib.c.

{
  if (!s)
    return 0;
  return mutt_strnwidth(s, mutt_str_len(s));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_strnwidth()

int mutt_strnwidth	(	const char *	s,
		size_t	n
	)

Measure a string's width in screen cells.

Parameters

s	String to be measured
n	Length of string to be measured

Return values

num	Screen cells string would use

Definition at line 1371 of file curs_lib.c.

{
  if (!s)
    return 0;

  wchar_t wc;
  int w;
  size_t k;
  mbstate_t mbstate;

  memset(&mbstate, 0, sizeof(mbstate));
  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 == (size_t)(-1)) || (k == (size_t)(-2)))
    {
      if (k == (size_t)(-1))
        memset(&mbstate, 0, sizeof(mbstate));
      k = (k == (size_t)(-1)) ? 1 : n;
      wc = ReplacementChar;
    }
    if (!IsWPrint(wc))
      wc = '?';
    w += wcwidth(wc);
  }
  return w;
}

Here is the caller graph for this function:

mutt_unget_event()

void mutt_unget_event	(	int	ch,
		int	op
	)

Return a keystroke to the input buffer.

Parameters

ch	Key press
op	Operation, e.g. OP_DELETE

This puts events into the UngetKeyEvents buffer

Definition at line 833 of file curs_lib.c.

{
  struct KeyEvent tmp;

  tmp.ch = ch;
  tmp.op = op;

  if (UngetCount >= UngetLen)
    mutt_mem_realloc(&UngetKeyEvents, (UngetLen += 16) * sizeof(struct KeyEvent));

  UngetKeyEvents[UngetCount++] = tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_unget_string()

void mutt_unget_string

(

const char *

s

)

Return a string to the input buffer.

Parameters

s	String to return

This puts events into the UngetKeyEvents buffer

Definition at line 852 of file curs_lib.c.

{
  const char *p = s + mutt_str_len(s) - 1;

  while (p >= s)
  {
    mutt_unget_event((unsigned char) *p--, 0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_wstr_trunc()

size_t mutt_wstr_trunc	(	const char *	src,
		size_t	maxlen,
		size_t	maxwid,
		size_t *	width
	)

Work out how to truncate a widechar string.

Parameters

[in]	src	String to measure
[in]	maxlen	Maximum length of string in bytes
[in]	maxwid	Maximum width in screen columns
[out]	width	Save the truncated screen column width

Return values

num	Bytes to use

See how many bytes to copy from string so it's at most maxlen bytes long and maxwid columns wide

Definition at line 1308 of file curs_lib.c.

{
  wchar_t wc;
  size_t n, w = 0, l = 0, cl;
  int cw;
  mbstate_t mbstate;

  if (!src)
    goto out;

  n = mutt_str_len(src);

  memset(&mbstate, 0, sizeof(mbstate));
  for (w = 0; n && (cl = mbrtowc(&wc, src, n, &mbstate)); src += cl, n -= cl)
  {
    if ((cl == (size_t)(-1)) || (cl == (size_t)(-2)))
    {
      if (cl == (size_t)(-1))
        memset(&mbstate, 0, sizeof(mbstate));
      cl = (cl == (size_t)(-1)) ? 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_yesorno()

enum QuadOption mutt_yesorno	(	const char *	msg,
		enum QuadOption	def
	)

Ask the user a Yes/No question.

Parameters

msg	Prompt
def	Default answer, MUTT_YES or MUTT_NO (see QuadOption)

Return values

num	Selection made, see QuadOption

Definition at line 378 of file curs_lib.c.

{
  struct KeyEvent ch;
  char *yes = _("yes");
  char *no = _("no");
  char *answer_string = NULL;
  int answer_string_wid, msg_wid;
  size_t trunc_msg_len;
  bool redraw = true;
  int prompt_lines = 1;

  char *expr = NULL;
  regex_t reyes;
  regex_t reno;
  char answer[2];

  answer[1] = '\0';

  bool reyes_ok = (expr = nl_langinfo(YESEXPR)) && (expr[0] == '^') &&
                  (REG_COMP(&reyes, expr, REG_NOSUB) == 0);
  bool reno_ok = (expr = nl_langinfo(NOEXPR)) && (expr[0] == '^') &&
                 (REG_COMP(&reno, expr, REG_NOSUB) == 0);

  /* In order to prevent the default answer to the question to wrapped
   * around the screen in the even the question is wider than the screen,
   * ensure there is enough room for the answer and truncate the question
   * to fit.  */
  mutt_str_asprintf(&answer_string, " ([%s]/%s): ", (def == MUTT_YES) ? yes : no,
                    (def == MUTT_YES) ? no : yes);
  answer_string_wid = mutt_strwidth(answer_string);
  msg_wid = mutt_strwidth(msg);

  while (true)
  {
    if (redraw || SigWinch)
    {
      redraw = false;
      if (SigWinch)
      {
        SigWinch = 0;
        mutt_resize_screen();
        clearok(stdscr, true);
        mutt_menu_current_redraw();
      }
      if (MessageWindow->state.cols)
      {
        prompt_lines = (msg_wid + answer_string_wid + MessageWindow->state.cols - 1) /
                       MessageWindow->state.cols;
        prompt_lines = MAX(1, MIN(3, prompt_lines));
      }
      if (prompt_lines != MessageWindow->state.rows)
      {
        mutt_window_reflow_message_rows(prompt_lines);
        mutt_menu_current_redraw();
      }

      /* maxlen here is sort of arbitrary, so pick a reasonable upper bound */
      trunc_msg_len = mutt_wstr_trunc(
          msg, (size_t) 4 * prompt_lines * MessageWindow->state.cols,
          ((size_t) prompt_lines * MessageWindow->state.cols) - answer_string_wid, NULL);

      mutt_window_move(MessageWindow, 0, 0);
      mutt_curses_set_color(MT_COLOR_PROMPT);
      mutt_window_addnstr(msg, trunc_msg_len);
      mutt_window_addstr(answer_string);
      mutt_curses_set_color(MT_COLOR_NORMAL);
      mutt_window_clrtoeol(MessageWindow);
    }

    mutt_refresh();
    /* SigWinch is not processed unless timeout is set */
    mutt_getch_timeout(30 * 1000);
    ch = mutt_getch();
    mutt_getch_timeout(-1);
    if (ch.ch == -2)
      continue;
    if (CI_is_return(ch.ch))
      break;
    if (ch.ch < 0)
    {
      def = MUTT_ABORT;
      break;
    }

    answer[0] = ch.ch;
    if (reyes_ok ? (regexec(&reyes, answer, 0, 0, 0) == 0) : (tolower(ch.ch) == 'y'))
    {
      def = MUTT_YES;
      break;
    }
    else if (reno_ok ? (regexec(&reno, answer, 0, 0, 0) == 0) : (tolower(ch.ch) == 'n'))
    {
      def = MUTT_NO;
      break;
    }
    else
    {
      mutt_beep(false);
    }
  }

  FREE(&answer_string);

  if (reyes_ok)
    regfree(&reyes);
  if (reno_ok)
    regfree(&reno);

  if (MessageWindow->state.rows == 1)
  {
    mutt_window_clearline(MessageWindow, 0);
  }
  else
  {
    mutt_window_reflow_message_rows(1);
    mutt_menu_current_redraw();
  }

  if (def == MUTT_ABORT)
  {
    /* when the users cancels with ^G, clear the message stored with
     * mutt_message() so it isn't displayed when the screen is refreshed. */
    mutt_clear_error();
  }
  else
  {
    mutt_window_addstr((char *) ((def == MUTT_YES) ? yes : no));
    mutt_refresh();
  }
  return def;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_quadoption()

enum QuadOption query_quadoption	(	enum QuadOption	opt,
		const char *	prompt
	)

Ask the user a quad-question.

Parameters

opt	Option to use
prompt	Message to show to the user

Return values

QuadOption

Result, e.g. MUTT_NO

Definition at line 516 of file curs_lib.c.

{
  switch (opt)
  {
    case MUTT_YES:
    case MUTT_NO:
      return opt;

    default:
      opt = mutt_yesorno(prompt, (opt == MUTT_ASKYES) ? MUTT_YES : MUTT_NO);
      mutt_window_clearline(MessageWindow, 0);
      return opt;
  }

  /* not reached */
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_buffer_get_field_full()

int mutt_buffer_get_field_full	(	const char *	field,
		struct Buffer *	buf,
		CompletionFlags	complete,
		bool	multiple,
		char ***	files,
		int *	numfiles
	)

Ask the user for a string.

Parameters

[in]	field	Prompt
[in]	buf	Buffer for the result
[in]	complete	Flags, see CompletionFlags
[in]	multiple	Allow multiple selections
[out]	files	List of files selected
[out]	numfiles	Number of files selected

Return values

1	Redraw the screen and call the function again
0	Selection made
-1	Aborted

Definition at line 258 of file curs_lib.c.

{
  int ret;
  int col;

  struct EnterState *es = mutt_enter_state_new();

  do
  {
    if (SigWinch)
    {
      SigWinch = 0;
      mutt_resize_screen();
      clearok(stdscr, true);
      mutt_menu_current_redraw();
    }
    mutt_window_clearline(MessageWindow, 0);
    mutt_curses_set_color(MT_COLOR_PROMPT);
    mutt_window_addstr(field);
    mutt_curses_set_color(MT_COLOR_NORMAL);
    mutt_refresh();
    mutt_window_get_coords(MessageWindow, &col, NULL);
    ret = mutt_enter_string_full(buf->data, buf->dsize, col, complete, multiple,
                                 files, numfiles, es);
  } while (ret == 1);

  if (ret == 0)
    mutt_buffer_fix_dptr(buf);
  else
    mutt_buffer_reset(buf);

  mutt_window_clearline(MessageWindow, 0);
  mutt_enter_state_free(&es);

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_buffer_enter_fname_full()

int mutt_buffer_enter_fname_full	(	const char *	prompt,
		struct Buffer *	fname,
		bool	mailbox,
		bool	multiple,
		char ***	files,
		int *	numfiles,
		SelectFileFlags	flags
	)

Ask the user to select a file.

Parameters

[in]	prompt	Prompt
[in]	fname	Buffer for the result
[in]	mailbox	If true, select mailboxes
[in]	multiple	Allow multiple selections
[out]	files	List of files selected
[out]	numfiles	Number of files selected
[in]	flags	Flags, see SelectFileFlags

Return values

0	Success
-1	Error

Definition at line 767 of file curs_lib.c.

{
  struct KeyEvent ch;

  mutt_curses_set_color(MT_COLOR_PROMPT);
  mutt_window_mvaddstr(MessageWindow, 0, 0, prompt);
  mutt_window_addstr(_(" ('?' for list): "));
  mutt_curses_set_color(MT_COLOR_NORMAL);
  if (!mutt_buffer_is_empty(fname))
    mutt_window_addstr(mutt_b2s(fname));
  mutt_window_clrtoeol(MessageWindow);
  mutt_refresh();

  do
  {
    ch = mutt_getch();
  } while (ch.ch == -2);
  if (ch.ch < 0)
  {
    mutt_window_clearline(MessageWindow, 0);
    return -1;
  }
  else if (ch.ch == '?')
  {
    mutt_refresh();
    mutt_buffer_reset(fname);

    if (flags == MUTT_SEL_NO_FLAGS)
      flags = MUTT_SEL_FOLDER;
    if (multiple)
      flags |= MUTT_SEL_MULTI;
    if (mailbox)
      flags |= MUTT_SEL_MAILBOX;
    mutt_buffer_select_file(fname, flags, files, numfiles);
  }
  else
  {
    char *pc = mutt_mem_malloc(mutt_str_len(prompt) + 3);

    sprintf(pc, "%s: ", prompt);
    if (ch.op == OP_NULL)
      mutt_unget_event(ch.ch, 0);
    else
      mutt_unget_event(0, ch.op);

    mutt_buffer_alloc(fname, 1024);
    if (mutt_buffer_get_field_full(pc, fname, (mailbox ? MUTT_EFILE : MUTT_FILE) | MUTT_CLEAR,
                                   multiple, files, numfiles) != 0)
    {
      mutt_buffer_reset(fname);
    }
    FREE(&pc);
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

C_MetaKey

bool C_MetaKey

interpret ALT-x as ESC-x

interpret ALT-x as ESC-x

Definition at line 71 of file curs_lib.c.

MuttGetchTimeout

int MuttGetchTimeout

Timeout in ms for mutt_getch()

Definition at line 92 of file curs_lib.c.