curs_lib.c File Reference

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

#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 "editor/lib.h"
#include "history/lib.h"
#include "key/lib.h"
#include "question/lib.h"
#include "globals.h"
#include "msgcont.h"
#include "msgwin.h"
#include "mutt_curses.h"
#include "mutt_logging.h"
#include "mutt_window.h"
#include "opcodes.h"
#include "thread.h"

Include dependency graph for curs_lib.c:

Go to the source code of this file.

Functions
void	mutt_beep (bool force)
	Irritate the user.
void	mutt_refresh (void)
	Force a refresh of the screen.
void	mutt_need_hard_redraw (void)
	Force a hard refresh.
void	mutt_edit_file (const char *editor, const char *file)
	Let the user edit a file.
void	mutt_query_exit (void)
	Ask the user if they want to leave NeoMutt.
void	mutt_endwin (void)
	Shutdown curses.
int	mutt_any_key_to_continue (const char *s)
	Prompt the user to 'press any key' and wait.
int	mw_enter_fname (const char *prompt, struct Buffer *fname, bool mailbox, struct Mailbox *m, bool multiple, char ***files, int *numfiles, SelectFileFlags flags)
	Ask the user to select a file -.
int	mutt_addwch (struct MuttWindow *win, wchar_t wc)
	Addwch would be provided by an up-to-date curses library.
void	mutt_paddstr (struct MuttWindow *win, int n, const char *s)
	Display a string on screen, padded if necessary.
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.
size_t	mutt_strwidth (const char *s)
	Measure a string's width in screen cells.
size_t	mutt_strnwidth (const char *s, size_t n)
	Measure a string's width in screen cells.
void	mw_what_key (void)
	Display the value of a key -.
void	mutt_str_expand_tabs (char **str, size_t *len, int tabwidth)
	Convert tabs to spaces in a string.

Detailed Description

GUI miscellaneous curses (window drawing) routines.

Authors

• Richard Russon
• Pietro Cerutti

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.c.

Function Documentation

mutt_beep()

void mutt_beep

(

bool

force

)

Irritate the user.

Parameters

force

If true, ignore the "$beep" config variable

Definition at line 68 of file curs_lib.c.

{
  const bool c_beep = cs_subset_bool(NeoMutt->sub, "beep");
  if (force || c_beep)
    beep();
}

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 78 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 */
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  if (!ARRAY_EMPTY(&mod_data->macro_events) && !OptForceRefresh)
    return;
 
  /* else */
  refresh();
}

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 101 of file curs_lib.c.

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

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 117 of file curs_lib.c.

{
  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();
 
  buf_pool_release(&cmd);
}

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 138 of file curs_lib.c.

{
  mutt_flushinp();
  if (query_yesorno(_("Exit NeoMutt without saving?"), MUTT_YES) == MUTT_YES)
  {
    mutt_exit(0); /* This call never returns */
  }
  mutt_clear_error();
  SigInt = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_endwin()

void mutt_endwin

(

void

)

Shutdown curses.

Definition at line 152 of file curs_lib.c.

{
  if (!OptGui)
    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();
  SigWinch = true;
 
  errno = e;
}

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 174 of file curs_lib.c.

{
  struct termios term = { 0 };
  struct termios old = { 0 };
 
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_addwch()

int mutt_addwch	(	struct MuttWindow *	win,
		wchar_t	wc )

Addwch would be provided by an up-to-date curses library.

Parameters

win	Window
wc	Wide char to display

Return values

0	Success
-1	Error

Definition at line 320 of file curs_lib.c.

{
  char buf[MB_LEN_MAX * 2] = { 0 };
  mbstate_t mbstate = { 0 };
  size_t n1;
  size_t 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);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_paddstr()

void mutt_paddstr	(	struct MuttWindow *	win,
		int	n,
		const char *	s )

Display a string on screen, padded if necessary.

Parameters

win	Window
n	Final width of field
s	String to display

Definition at line 344 of file curs_lib.c.

{
  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_addwch(win, wc);
      n -= w;
    }
  }
  while (n-- > 0)
    mutt_window_addch(win, ' ');
}

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 386 of file curs_lib.c.

{
  wchar_t wc = 0;
  size_t n;
  size_t w = 0;
  size_t l = 0;
  size_t 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)
    {
      memset(&mbstate, 0, sizeof(mbstate));
      cl = 1;
      wc = ReplacementChar;
    }
    else if (cl == ICONV_BUF_TOO_SMALL)
    {
      cl = 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 (wc == '\n')
      break;
    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_strwidth()

size_t 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 449 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()

size_t 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 462 of file curs_lib.c.

{
  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)
    {
      if (n < 2)
        break;
      s += 2; /* skip the index coloring sequence */
      n -= 2;
      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;
}

Here is the caller graph for this function:

mutt_str_expand_tabs()

void mutt_str_expand_tabs	(	char **	str,
		size_t *	len,
		int	tabwidth )

Convert tabs to spaces in a string.

Parameters

str	Input/output string
len	Length of the string
tabwidth	The number of spaces per indentation-level

Replace tab characters (\t) with spaces in the string. The string will be resized to fit the expanded version if necessary.

Definition at line 601 of file curs_lib.c.

{
  if (!str || !*str || !len || (tabwidth < 1))
  {
    return;
  }
 
  char *in = *str;
 
  // calculate how much space we need
  size_t required_len = 0;
  bool found_tabs = false;
  for (int i = 0; (i < *len) && (in[i] != '\0'); i++)
  {
    if (in[i] == '\t')
    {
      found_tabs = true;
      required_len += tabwidth; // cheat, just assume full tab width
    }
    else
    {
      required_len++;
    }
  }
 
  if (!found_tabs)
  {
    return;
  }
 
  // tab expansion can fill in the whole buffer; we need to make some more room
  // for the \0-terminator.
  if (required_len == *len)
  {
    ++required_len;
  }
 
  // resize the string if there isn't enough space
  if (required_len > *len)
  {
    *len = ROUND_UP(required_len, 256);
  }
  char *out = MUTT_MEM_CALLOC(*len, char);
 
  // expand tabs
  for (int i = 0, o = 0; in[i] != '\0'; i++)
  {
    if (in[i] == '\t')
    {
      // TODO - we could keep a running width instead of recomputing this from
      // scratch for each encountered tab.
      int num_cells = mutt_strnwidth(out, o);
      int indent = abs((num_cells % tabwidth) - tabwidth);
      memset(out + o, ' ', indent);
      o += indent;
    }
    else
    {
      out[o] = in[i];
      ++o;
    }
  }
 
  FREE(str);
  *str = out;
}

Here is the call graph for this function:

Here is the caller graph for this function: