protos.h File Reference

Prototypes for many functions. More...

#include "config.h"
#include <stdbool.h>
#include "mutt.h"
#include "menu/lib.h"

Include dependency graph for protos.h:

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

Go to the source code of this file.

Enumerations
enum	XdgType { XDG_CONFIG_HOME , XDG_CONFIG_DIRS }
	XDG variable types. More...
enum	EvMessage { EVM_VIEW , EVM_EDIT }
	Edit or View a message. More...

Functions
int	mutt_ev_message (struct Mailbox *m, struct EmailArray *ea, enum EvMessage action)
	Edit or view a message.
int	mutt_system (const char *cmd)
	Run an external command.
int	mutt_set_xdg_path (enum XdgType type, struct Buffer *buf)
	Find an XDG path or its fallback.
void	mutt_help (enum MenuType menu)
	Display the help menu.
void	mutt_set_flag (struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool upd_mbox)
	Set a flag on an email.
void	mutt_signal_init (void)
	Initialise the signal handling.
void	mutt_emails_set_flag (struct Mailbox *m, struct EmailArray *ea, enum MessageType flag, bool bf)
	Set flag on messages.
int	mw_change_flag (struct Mailbox *m, struct EmailArray *ea, bool bf)
	Change the flag on a Message -.
int	mutt_thread_set_flag (struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool subthread)
	Set a flag on an entire thread.
int	wcscasecmp (const wchar_t *a, const wchar_t *b)
	Compare two wide-character strings, ignoring case.
int	mutt_reply_observer (struct NotifyCallback *nc)

Variables
short	PostCount
	Number of postponed (draft) emails.

Detailed Description

Prototypes for many functions.

Authors

• Michael R. Elkins
• Karel Zak
• 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 protos.h.

Enumeration Type Documentation

XdgType

enum XdgType

XDG variable types.

Enumerator
XDG_CONFIG_HOME	XDG home dir: ~/.config.
XDG_CONFIG_DIRS	XDG system dir: /etc/xdg.

Definition at line 42 of file protos.h.

{
  XDG_CONFIG_HOME, 
  XDG_CONFIG_DIRS, 
};

EvMessage

enum EvMessage

Edit or View a message.

Enumerator
EVM_VIEW	View the message.
EVM_EDIT	Edit the message.

Definition at line 51 of file protos.h.

{
  EVM_VIEW, 
  EVM_EDIT, 
};

Function Documentation

mutt_ev_message()

int mutt_ev_message	(	struct Mailbox *	m,
		struct EmailArray *	ea,
		enum EvMessage	action
	)

Edit or view a message.

Parameters

m	Mailbox
ea	Array of Emails
action	Action to perform, e.g. EVM_EDIT

Return values

1	Message not modified
0	Message edited successfully
-1	Error

Definition at line 284 of file editmsg.c.

{
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, ea)
  {
    struct Email *e = *ep;
    if (ev_message(action, m, e) == -1)
      return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_system()

int mutt_system

(

const char *

cmd

)

Run an external command.

Parameters

cmd	Command and arguments

Return values

-1	Error
>=0	Success (command's return code)

Fork and run an external command with arguments.

Note

This function won't return until the command finishes.

Definition at line 52 of file system.c.

{
  int rc = -1;
  struct sigaction act = { 0 };
  struct sigaction oldtstp = { 0 };
  struct sigaction oldcont = { 0 };
  pid_t pid;
 
  if (!cmd || (*cmd == '\0'))
    return 0;
 
  /* must ignore SIGINT and SIGQUIT */
 
  mutt_sig_block_system();
 
  act.sa_handler = SIG_DFL;
/* we want to restart the waitpid() below */
#ifdef SA_RESTART
  act.sa_flags = SA_RESTART;
#endif
  sigemptyset(&act.sa_mask);
  sigaction(SIGTSTP, &act, &oldtstp);
  sigaction(SIGCONT, &act, &oldcont);
 
  pid = fork();
  if (pid == 0)
  {
    act.sa_flags = 0;
 
    mutt_sig_unblock_system(false);
    mutt_sig_reset_child_signals();
 
    execle(EXEC_SHELL, "sh", "-c", cmd, NULL, EnvList);
    _exit(127); /* execl error */
  }
  else if (pid != -1)
  {
    rc = imap_wait_keep_alive(pid);
  }
 
  sigaction(SIGCONT, &oldcont, NULL);
  sigaction(SIGTSTP, &oldtstp, NULL);
 
  /* reset SIGINT, SIGQUIT and SIGCHLD */
  mutt_sig_unblock_system(true);
 
  rc = (pid != -1) ? (WIFEXITED(rc) ? WEXITSTATUS(rc) : -1) : -1;
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_set_xdg_path()

int mutt_set_xdg_path	(	enum XdgType	type,
		struct Buffer *	buf
	)

Find an XDG path or its fallback.

Parameters

type	Type of XDG variable, e.g. XDG_CONFIG_HOME
buf	Buffer to save path

Return values

1	An entry was found that actually exists on disk and 0 otherwise

Process an XDG environment variable or its fallback.

Definition at line 897 of file muttlib.c.

{
  const char *xdg_env = mutt_str_getenv(XdgEnvVars[type]);
  char *xdg = xdg_env ? mutt_str_dup(xdg_env) : mutt_str_dup(XdgDefaults[type]);
  char *x = xdg; /* mutt_str_sep() changes xdg, so free x instead later */
  char *token = NULL;
  int rc = 0;
 
  while ((token = mutt_str_sep(&xdg, ":")))
  {
    if (buf_printf(buf, "%s/%s/neomuttrc", token, PACKAGE) < 0)
      continue;
    buf_expand_path(buf);
    if (access(buf_string(buf), F_OK) == 0)
    {
      rc = 1;
      break;
    }
 
    if (buf_printf(buf, "%s/%s/Muttrc", token, PACKAGE) < 0)
      continue;
    buf_expand_path(buf);
    if (access(buf_string(buf), F_OK) == 0)
    {
      rc = 1;
      break;
    }
  }
 
  FREE(&x);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_help()

void mutt_help

(

enum MenuType

menu

)

Display the help menu.

Parameters

menu	Current Menu

Definition at line 467 of file help.c.

{
  char banner[128] = { 0 };
  FILE *fp = NULL;
 
  struct Buffer *tmp_file = buf_pool_get();
  buf_mktemp(tmp_file);
 
  const struct MenuFuncOp *funcs = km_get_table(menu);
  const char *desc = mutt_map_get_name(menu, MenuNames);
  if (!desc)
    desc = _("<UNKNOWN>");
 
  struct PagerData pdata = { 0 };
  struct PagerView pview = { &pdata };
 
  pview.mode = PAGER_MODE_HELP;
  pview.flags = MUTT_PAGER_RETWINCH | MUTT_PAGER_MARKER | MUTT_PAGER_NSKIP |
                MUTT_PAGER_NOWRAP | MUTT_PAGER_STRIPES;
 
  do
  {
    fp = mutt_file_fopen(buf_string(tmp_file), "w");
    if (!fp)
    {
      mutt_perror("%s", buf_string(tmp_file));
      goto cleanup;
    }
 
    const int wraplen = AllDialogsWindow->state.cols;
    dump_menu(fp, menu, wraplen);
    if ((menu != MENU_EDITOR) && (menu != MENU_PAGER) && (menu != MENU_GENERIC))
    {
      fprintf(fp, "\n%s\n\n", _("Generic bindings:"));
      dump_menu(fp, MENU_GENERIC, wraplen);
    }
 
    fprintf(fp, "\n%s\n\n", _("Unbound functions:"));
    if (funcs)
      dump_unbound(fp, funcs, &Keymaps[menu], NULL, wraplen);
    if ((menu != MENU_EDITOR) && (menu != MENU_PAGER) && (menu != MENU_GENERIC))
      dump_unbound(fp, OpGeneric, &Keymaps[MENU_GENERIC], &Keymaps[menu], wraplen);
 
    if (menu == MENU_INDEX)
    {
      fprintf(fp, "\n%s\n\n", _("Message flags:"));
      dump_message_flags(fp, wraplen);
    }
 
    mutt_file_fclose(&fp);
 
    snprintf(banner, sizeof(banner), _("Help for %s"), desc);
    pdata.fname = buf_string(tmp_file);
    pview.banner = banner;
  } while (mutt_do_pager(&pview, NULL) == OP_REFORMAT_WINCH);
 
cleanup:
  buf_pool_release(&tmp_file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_set_flag()

void mutt_set_flag	(	struct Mailbox *	m,
		struct Email *	e,
		enum MessageType	flag,
		bool	bf,
		bool	upd_mbox
	)

Set a flag on an email.

Parameters

m	Mailbox
e	Email
flag	Flag to set, e.g. MUTT_DELETE
bf	true: set the flag; false: clear the flag
upd_mbox	true: update the Mailbox

Definition at line 57 of file flags.c.

{
  if (!m || !e)
    return;
 
  bool changed = e->changed;
  int deleted = m->msg_deleted;
  int tagged = m->msg_tagged;
  int flagged = m->msg_flagged;
  int update = false;
 
  if (m->readonly && (flag != MUTT_TAG))
    return; /* don't modify anything if we are read-only */
 
  switch (flag)
  {
    case MUTT_DELETE:
    {
      if (!(m->rights & MUTT_ACL_DELETE))
        return;
 
      if (bf)
      {
        const bool c_flag_safe = cs_subset_bool(NeoMutt->sub, "flag_safe");
        if (!e->deleted && !m->readonly && (!e->flagged || !c_flag_safe))
        {
          e->deleted = true;
          update = true;
          if (upd_mbox)
            m->msg_deleted++;
          /* deleted messages aren't treated as changed elsewhere so that the
           * purge-on-sync option works correctly. This isn't applicable here */
          if (m->type == MUTT_IMAP)
          {
            e->changed = true;
            if (upd_mbox)
              m->changed = true;
          }
        }
      }
      else if (e->deleted)
      {
        e->deleted = false;
        update = true;
        if (upd_mbox)
          m->msg_deleted--;
        /* see my comment above */
        if (m->type == MUTT_IMAP)
        {
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
        /* If the user undeletes a message which is marked as
         * "trash" in the maildir folder on disk, the folder has
         * been changed, and is marked accordingly.  However, we do
         * _not_ mark the message itself changed, because trashing
         * is checked in specific code in the maildir folder
         * driver.  */
        if ((m->type == MUTT_MAILDIR) && upd_mbox && e->trash)
          m->changed = true;
      }
      break;
    }
    case MUTT_PURGE:
    {
      if (!(m->rights & MUTT_ACL_DELETE))
        return;
 
      if (bf)
      {
        if (!e->purge && !m->readonly)
          e->purge = true;
      }
      else if (e->purge)
      {
        e->purge = false;
      }
      break;
    }
    case MUTT_NEW:
    {
      if (!(m->rights & MUTT_ACL_SEEN))
        return;
 
      if (bf)
      {
        if (e->read || e->old)
        {
          update = true;
          e->old = false;
          if (upd_mbox)
            m->msg_new++;
          if (e->read)
          {
            e->read = false;
            if (upd_mbox)
              m->msg_unread++;
          }
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (!e->read)
      {
        update = true;
        if (!e->old)
          if (upd_mbox)
            m->msg_new--;
        e->read = true;
        if (upd_mbox)
          m->msg_unread--;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_OLD:
    {
      if (!(m->rights & MUTT_ACL_SEEN))
        return;
 
      if (bf)
      {
        if (!e->old)
        {
          update = true;
          e->old = true;
          if (!e->read)
            if (upd_mbox)
              m->msg_new--;
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (e->old)
      {
        update = true;
        e->old = false;
        if (!e->read)
          if (upd_mbox)
            m->msg_new++;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_READ:
    {
      if (!(m->rights & MUTT_ACL_SEEN))
        return;
 
      if (bf)
      {
        if (!e->read)
        {
          update = true;
          e->read = true;
          if (upd_mbox)
            m->msg_unread--;
          if (!e->old)
            if (upd_mbox)
              m->msg_new--;
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (e->read)
      {
        update = true;
        e->read = false;
        if (upd_mbox)
          m->msg_unread++;
        if (!e->old)
          if (upd_mbox)
            m->msg_new++;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_REPLIED:
    {
      if (!(m->rights & MUTT_ACL_WRITE))
        return;
 
      if (bf)
      {
        if (!e->replied)
        {
          update = true;
          e->replied = true;
          if (!e->read)
          {
            e->read = true;
            if (upd_mbox)
              m->msg_unread--;
            if (!e->old)
              if (upd_mbox)
                m->msg_new--;
          }
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (e->replied)
      {
        update = true;
        e->replied = false;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_FLAG:
    {
      if (!(m->rights & MUTT_ACL_WRITE))
        return;
 
      if (bf)
      {
        if (!e->flagged)
        {
          update = true;
          e->flagged = bf;
          if (upd_mbox)
            m->msg_flagged++;
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (e->flagged)
      {
        update = true;
        e->flagged = false;
        if (upd_mbox)
          m->msg_flagged--;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_TAG:
    {
      if (bf)
      {
        if (!e->tagged)
        {
          update = true;
          e->tagged = true;
          if (upd_mbox)
            m->msg_tagged++;
        }
      }
      else if (e->tagged)
      {
        update = true;
        e->tagged = false;
        if (upd_mbox)
          m->msg_tagged--;
      }
      break;
    }
    default:
    {
      break;
    }
  }
 
  if (update)
  {
    mutt_set_header_color(m, e);
    struct EventMailbox ev_m = { m };
    notify_send(m->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
  }
 
  /* if the message status has changed, we need to invalidate the cached
   * search results so that any future search will match the current status
   * of this message and not what it was at the time it was last searched.  */
  if (e->searched && ((changed != e->changed) || (deleted != m->msg_deleted) ||
                      (tagged != m->msg_tagged) || (flagged != m->msg_flagged)))
  {
    e->searched = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_signal_init()

void mutt_signal_init

(

void

)

Initialise the signal handling.

Definition at line 130 of file mutt_signal.c.

{
  mutt_sig_init(curses_signal_handler, curses_exit_handler, curses_segv_handler);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_emails_set_flag()

void mutt_emails_set_flag	(	struct Mailbox *	m,
		struct EmailArray *	ea,
		enum MessageType	flag,
		bool	bf
	)

Set flag on messages.

Parameters

m	Mailbox
ea	Array of Emails to flag
flag	Flag to set, e.g. MUTT_DELETE
bf	true: set the flag; false: clear the flag

Definition at line 361 of file flags.c.

{
  if (!m || !ea || ARRAY_EMPTY(ea))
    return;
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, ea)
  {
    struct Email *e = *ep;
    mutt_set_flag(m, e, flag, bf, true);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_thread_set_flag()

int mutt_thread_set_flag	(	struct Mailbox *	m,
		struct Email *	e,
		enum MessageType	flag,
		bool	bf,
		bool	subthread
	)

Set a flag on an entire thread.

Parameters

m	Mailbox
e	Email
flag	Flag to set, e.g. MUTT_DELETE
bf	true: set the flag; false: clear the flag
subthread	If true apply to all of the thread

Return values

0	Success
-1	Failure

Definition at line 385 of file flags.c.

{
  struct MuttThread *start = NULL;
  struct MuttThread *cur = e->thread;
 
  if (!mutt_using_threads())
  {
    mutt_error(_("Threading is not enabled"));
    return -1;
  }
 
  if (!subthread)
    while (cur->parent)
      cur = cur->parent;
 
  start = cur;
 
  if (cur->message && (cur != e->thread))
    mutt_set_flag(m, cur->message, flag, bf, true);
 
  cur = cur->child;
  if (!cur)
    goto done;
 
  while (true)
  {
    if (cur->message && (cur != e->thread))
      mutt_set_flag(m, cur->message, flag, bf, true);
 
    if (cur->child)
    {
      cur = cur->child;
    }
    else if (cur->next)
    {
      cur = cur->next;
    }
    else
    {
      while (!cur->next)
      {
        cur = cur->parent;
        if (cur == start)
          goto done;
      }
      cur = cur->next;
    }
  }
done:
  cur = e->thread;
  if (cur->message)
    mutt_set_flag(m, cur->message, flag, bf, true);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

wcscasecmp()

int wcscasecmp	(	const wchar_t *	a,
		const wchar_t *	b
	)

Compare two wide-character strings, ignoring case.

Parameters

a	First string
b	Second string

Return values

-1	a precedes b
0	a and b are identical
1	b precedes a

Definition at line 41 of file wcscasecmp.c.

{
  if (!a && !b)
    return 0;
  if (!a && b)
    return -1;
  if (a && !b)
    return 1;
 
  for (; *a || *b; a++, b++)
  {
    int i = towlower(*a);
    if ((i - towlower(*b)) != 0)
      return i;
  }
  return 0;
}

Here is the caller graph for this function:

mutt_reply_observer()

int mutt_reply_observer

(

struct NotifyCallback *

nc

)

Variable Documentation

PostCount

short PostCount

extern

Number of postponed (draft) emails.

Definition at line 58 of file postpone.c.