"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
<book>
<bookinfo>
- <title>The Mutt E-Mail Client</title>
+ <title>The NeoMutt E-Mail Client</title>
<author>
<firstname>Michael</firstname>
<surname>Elkins</surname>
<chapter id="intro">
<title>Introduction</title>
<para>
- <emphasis role="bold">Mutt</emphasis> is a small but very powerful
- text-based MIME mail client. Mutt is highly configurable, and is well
+ <emphasis role="bold">NeoMutt</emphasis> is a small but very powerful
+ text-based MIME mail client. NeoMutt is highly configurable, and is well
suited to the mail power user with advanced features like key bindings,
keyboard macros, mail threading, regular expression searches and a powerful
pattern matching language for selecting groups of messages.</para>
</sect1>
<sect1 id="contrib">
- <title>Contributing to Mutt</title>
- <para>There are various ways to contribute to the Mutt project.</para>
+ <title>Contributing to NeoMutt</title>
+ <para>There are various ways to contribute to the NeoMutt project.</para>
<para>Especially for new users it may be helpful to meet other new and
- experienced users to chat about Mutt, talk about problems and share
+ experienced users to chat about NeoMutt, talk about problems and share
tricks.</para>
- <para>Since translations of Mutt into other languages are highly
- appreciated, the Mutt developers always look for skilled translators that
+ <para>Since translations of NeoMutt into other languages are highly
+ appreciated, the NeoMutt developers always look for skilled translators that
help improve and continue to maintain stale translations.</para>
<para>For contributing code patches for new features and bug fixes,
please refer to the developer pages at
<entry>
<literal><create-alias></literal>
</entry>
- <entry>named Mutt function</entry>
+ <entry>named NeoMutt function</entry>
</row>
<row>
<entry>
</row>
<row>
<entry>$mail_check</entry>
- <entry>Mutt configuration option</entry>
+ <entry>NeoMutt configuration option</entry>
</row>
<row>
<entry>
</tgroup>
</table>
<para>Examples are presented as:</para>
- <screen>mutt -v</screen>
+ <screen>neomutt -v</screen>
<para>Within command synopsis, curly brackets (
<quote>{}</quote>) denote a set of options of which one is mandatory,
square brackets (
<sect1 id="copyright">
<title>Copyright</title>
- <para>Mutt is Copyright © 1996-2016 Michael R. Elkins
- <email>me@mutt.org</email> and others.</para>
+ <para>NeoMutt is Copyright © 1996-2016 Michael R. Elkins
+ <email>me@neomutt.org</email> and others.</para>
<para>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
<chapter id="gettingstarted">
<title>Getting Started</title>
- <para>This section is intended as a brief overview of how to use Mutt.
+ <para>This section is intended as a brief overview of how to use NeoMutt.
There are many other features which are described elsewhere in the manual.
- There is even more information available in the Mutt FAQ and various web
+ There is even more information available in the NeoMutt FAQ and various web
pages. See the
- <ulink url="http://www.mutt.org/">Mutt homepage</ulink> for more
+ <ulink url="http://www.neomutt.org/">NeoMutt homepage</ulink> for more
details.</para>
<para>The keybindings described in this section are the defaults as
distributed. Your local system administrator may have altered the defaults
for your site. You can always type
<quote>?</quote>in any menu to display the current bindings.</para>
- <para>The first thing you need to do is invoke Mutt, simply by typing
- <literal>mutt</literal> at the command line. There are various command-line
- options, see either the Mutt man page or the
+ <para>The first thing you need to do is invoke NeoMutt, simply by typing
+ <literal>neomutt</literal> at the command line. There are various command-line
+ options, see either the NeoMutt man page or the
<link linkend="commandline">reference</link>.</para>
<sect1 id="core-concepts">
<title>Core Concepts</title>
- <para>Mutt is a text-based application which interacts with users through
+ <para>NeoMutt is a text-based application which interacts with users through
different menus which are mostly line-/entry-based or page-based. A
line-based menu is the so-called
<quote>index</quote> menu (listing all messages of the currently opened
finally the command line. The command line is used to display
informational and error messages as well as for prompts and for entering
interactive commands.</para>
- <para>Mutt is configured through variables which, if the user wants to
+ <para>NeoMutt is configured through variables which, if the user wants to
permanently use a non-default value, are written to configuration files.
- Mutt supports a rich config file syntax to make even complex
+ NeoMutt supports a rich config file syntax to make even complex
configuration files readable and commentable.</para>
- <para>Because Mutt allows for customizing almost all key bindings, there
+ <para>Because NeoMutt allows for customizing almost all key bindings, there
are so-called
<quote>functions</quote> which can be executed manually (using the command
line) or in macros. Macros allow the user to bind a sequence of commands
<para>Many commands (such as saving or copying a message to another
folder) can be applied to a single message or a set of messages
(so-called
- <quote>tagged</quote> messages). To help selecting messages, Mutt provides
+ <quote>tagged</quote> messages). To help selecting messages, NeoMutt provides
a rich set of message patterns (such as recipients, sender, body
contents, date sent/received, etc.) which can be combined into complex
expressions using the boolean
<emphasis>or</emphasis> operations as well as negating. These patterns can
also be used to (for example) search for messages or to limit the index
to show only matching messages.</para>
- <para>Mutt supports a
+ <para>NeoMutt supports a
<quote>hook</quote> concept which allows the user to execute arbitrary
configuration commands and functions in certain situations such as
entering a folder, starting a new message or replying to an existing one.
- These hooks can be used to highly customize Mutt's behavior including
+ These hooks can be used to highly customize NeoMutt's behavior including
managing multiple identities, customizing the display for a folder or
even implementing auto-archiving based on a per-folder basis and much
more.</para>
- <para>Besides an interactive mode, Mutt can also be used as a
+ <para>Besides an interactive mode, NeoMutt can also be used as a
command-line tool only send messages. It also supports a
<literal>mailx(1)</literal>-compatible interface, see
<xref linkend="tab-commandline-options" />for a complete list of
<sect2 id="intro-index">
<title>Index</title>
<para>The index is the screen that you usually see first when you start
- Mutt. It gives an overview over your emails in the currently opened
+ NeoMutt. It gives an overview over your emails in the currently opened
mailbox. By default, this is your system mailbox. The information you
see in the index is a list of emails, each with its number on the left,
its flags (new email, important email, email that has been forwarded or
information about them below the email body, or, if the attachments are
text files, you can view them directly in the pager.</para>
<para>To give the user a good overview, it is possible to configure
- Mutt to show different things in the pager with different colors.
+ NeoMutt to show different things in the pager with different colors.
Virtually everything that can be described with a regular expression
can be colored, e.g. URLs, email addresses or smileys.</para>
</sect2>
turned on and off, it can be themed and the list style can be
configured.</para>
<para>This part of the manual is suitable for beginners. If you already
- know Mutt you could skip ahead to the main
+ know NeoMutt you could skip ahead to the main
<link linkend="sidebar">Sidebar guide</link>. If you just want to get
started, you could use the sample
<link linkend="sidebar-muttrc">Sidebar muttrc</link>.</para>
- <para>To check if Mutt supports
+ <para>To check if NeoMutt supports
<quote>Sidebar</quote>, look for the string
- <literal>+sidebar</literal> in the mutt version.</para>
- <screen>mutt -v</screen>
+ <literal>+sidebar</literal> in the neomutt version.</para>
+ <screen>neomutt -v</screen>
<para>
<emphasis role="bold">Let's turn on the Sidebar:</emphasis>
</para>
<sect3 id="intro-sidebar-navigation">
<title>Navigation</title>
<para>The Sidebar adds some new
- <link linkend="sidebar-functions">functions</link> to Mutt.</para>
+ <link linkend="sidebar-functions">functions</link> to NeoMutt.</para>
<para>The user pressed the
<quote>c</quote> key to
<literal><change-folder></literal>to the
lists the current configuration of key bindings and their associated
commands including a short description, and currently unbound functions
that still need to be associated with a key binding (or alternatively,
- they can be called via the Mutt command prompt).</para>
+ they can be called via the NeoMutt command prompt).</para>
</sect2>
<sect2 id="intro-compose">
<sect2 id="intro-attach">
<title>Attachment Menu</title>
- <para>As will be later discussed in detail, Mutt features a good and
+ <para>As will be later discussed in detail, NeoMutt features a good and
stable MIME implementation, that is, it supports sending and receiving
messages of arbitrary MIME types. The attachment menu displays a
message's structure in detail: what content parts are attached to which
<sect2 id="editing-intro">
<title>Introduction</title>
- <para>Mutt has a built-in line editor for inputting text, e.g. email
+ <para>NeoMutt has a built-in line editor for inputting text, e.g. email
addresses or filenames. The keys used to manipulate text input are very
similar to those of Emacs. See
<xref linkend="tab-keys-editor" />for a full reference of available
<sect2 id="editing-history">
<title>History</title>
- <para>Mutt maintains a history for the built-in editor. The number of
+ <para>NeoMutt maintains a history for the built-in editor. The number of
items is controlled by the
<link linkend="history">$history</link> variable and can be made
persistent using an external file specified using
<link linkend="save-history">$save_history</link>. You may cycle
through them at an editor prompt by using the
<literal><history-up></literal>and/or
- <literal><history-down></literal>commands. Mutt will remember the
+ <literal><history-down></literal>commands. NeoMutt will remember the
currently entered text as you cycle through history, and will wrap
around to the initial entry line.</para>
- <para>Mutt maintains several distinct history lists, one for each of
+ <para>NeoMutt maintains several distinct history lists, one for each of
the following categories:</para>
<itemizedlist>
<listitem>
<para>everything else</para>
</listitem>
</itemizedlist>
- <para>Mutt automatically filters out consecutively repeated items from
+ <para>NeoMutt automatically filters out consecutively repeated items from
the history. If
<link linkend="history-remove-dups">$history_remove_dups</link> is set,
all repeated items are removed from the history. It also mimics the
<sect1 id="reading">
<title>Reading Mail</title>
<para>Similar to many other mail clients, there are two modes in which
- mail is read in Mutt. The first is a list of messages in the mailbox,
+ mail is read in NeoMutt. The first is a list of messages in the mailbox,
which is called the
- <quote>index</quote> menu in Mutt. The second mode is the display of the
+ <quote>index</quote> menu in NeoMutt. The second mode is the display of the
message contents. This is called the
<quote>pager.</quote></para>
<para>The next few sections describe the functions provided in each of
<sect2 id="pager-menu">
<title>The Pager</title>
- <para>By default, Mutt uses its built-in pager to display the contents
+ <para>By default, NeoMutt uses its built-in pager to display the contents
of messages (an external pager such as
<literal>less(1)</literal>can be configured, see
<link linkend="pager">$pager</link> variable). The pager is very similar
<quote>standard</quote> nroff sequences for bold and underline. These
sequences are a series of either the letter, backspace (
<quote>^H</quote>), the letter again for bold or the letter, backspace,
- <quote>_</quote> for denoting underline. Mutt will attempt to display
+ <quote>_</quote> for denoting underline. NeoMutt will attempt to display
these in bold and underline respectively if your terminal supports
them. If not, you can use the bold and underline
<link linkend="color">color</link> objects to specify a
<command>color</command> or mono attribute for them.</para>
<para>Additionally, the internal pager supports the ANSI escape
- sequences for character attributes. Mutt translates them into the
- correct color and character settings. The sequences Mutt supports
+ sequences for character attributes. NeoMutt translates them into the
+ correct color and character settings. The sequences NeoMutt supports
are:</para>
<screen>\e[
<emphasis>Ps</emphasis>;
</tbody>
</tgroup>
</table>
- <para>Mutt uses these attributes for handling
+ <para>NeoMutt uses these attributes for handling
<literal>text/enriched</literal> messages, and they can also be used by
an external
<link linkend="auto-view">autoview</link> script for highlighting
<quote>threads</quote> provide a hierarchy of messages where replies are
linked to their parent message(s). This organizational form is
extremely useful in mailing lists where different parts of the
- discussion diverge. Mutt displays threads as a tree structure.</para>
- <para>In Mutt, when a mailbox is
+ discussion diverge. NeoMutt displays threads as a tree structure.</para>
+ <para>In NeoMutt, when a mailbox is
<link linkend="sort">sorted</link> by
<emphasis>threads</emphasis>, there are a few additional functions
available in the
<link linkend="formatstrings-conditionals">format string
conditionals</link>.</para>
<para>Technically, every reply should contain a list of its parent
- messages in the thread tree, but not all do. In these cases, Mutt
+ messages in the thread tree, but not all do. In these cases, NeoMutt
groups them by subject which can be controlled using the
<link linkend="strict-threads">$strict_threads</link> variable.</para>
</sect2>
<link linkend="alias-file">$alias_file</link> variable for future
use</para>
<note>
- <para>Mutt does not read the
+ <para>NeoMutt does not read the
<link linkend="alias-file">$alias_file</link> upon startup so
you must explicitly
<link linkend="source">
<literal><resend-message></literal>
<anchor id="resend-message" />(default: Esc e)</term>
<listitem>
- <para>Mutt takes the current message as a template for a new
+ <para>NeoMutt takes the current message as a template for a new
message. This function is best described as "recall from
arbitrary folders". It can conveniently be used to forward MIME
messages while preserving the original mail structure. Note that
<listitem>
<para>Asks for an external Unix command and executes it. The
<link linkend="wait-key">$wait_key</link> can be used to control
- whether Mutt will wait for a key to be pressed when the command
+ whether NeoMutt will wait for a key to be pressed when the command
returns (presumably to let the user read the output of the
command), based on the return status of the named command. If no
command is given, an interactive shell is executed.</para>
<quote>
<link linkend="forwarding-mail">Forwarding and Bouncing
Mail</link>.</quote></para>
- <para>Mutt will then enter the
+ <para>NeoMutt will then enter the
<emphasis>compose</emphasis> menu and prompt you for the recipients to
place on the
<quote>To:</quote>header field when you hit
<link linkend="autoedit">$autoedit</link>,
<link linkend="bounce">$bounce</link>,
<link linkend="fast-reply">$fast_reply</link>, and
- <link linkend="include">$include</link> for changing how and if Mutt
+ <link linkend="include">$include</link> for changing how and if NeoMutt
asks these questions.</para>
- <para>When replying, Mutt fills these fields with proper values
+ <para>When replying, NeoMutt fills these fields with proper values
depending on the reply type. The types of replying supported
are:</para>
<variablelist>
</varlistentry>
</variablelist>
<para>After getting recipients for new messages, forwards or replies,
- Mutt will then automatically start your
+ NeoMutt will then automatically start your
<link linkend="editor">$editor</link> on the message body. If the
<link linkend="edit-headers">$edit_headers</link> variable is set, the
headers will be at the top of the message in your editor; the message
<para>When editing the header because of
<link linkend="edit-headers">$edit_headers</link> being set, there are a
several pseudo headers available which will not be included in sent
- messages but trigger special Mutt behavior.</para>
+ messages but trigger special NeoMutt behavior.</para>
<sect3 id="fcc-header">
<title>Fcc: Pseudo Header</title>
<literal>Fcc:</literal>
<emphasis>filename</emphasis>
</para>
- <para>as a header, Mutt will pick up
+ <para>as a header, NeoMutt will pick up
<emphasis>filename</emphasis> just as if you had used the
<literal><edit-fcc></literal>function in the
<emphasis>compose</emphasis> menu. It can later be changed from the
<title>In-Reply-To: Header</title>
<para>When replying to messages, the
<emphasis>In-Reply-To:</emphasis>header contains the Message-Id of
- the message(s) you reply to. If you remove or modify its value, Mutt
+ the message(s) you reply to. If you remove or modify its value, NeoMutt
will not generate a
<emphasis>References:</emphasis>field, which allows you to create a
new message thread, for example to create a new message to a mailing
<sect2 id="sending-crypto">
<title>Sending Cryptographically Signed/Encrypted Messages</title>
- <para>If you have told Mutt to PGP or S/MIME encrypt a message, it will
+ <para>If you have told NeoMutt to PGP or S/MIME encrypt a message, it will
guide you through a key selection process when you try to send the
- message. Mutt will not ask you any questions about keys which have a
+ message. NeoMutt will not ask you any questions about keys which have a
certified user ID matching one of the message recipients' mail
addresses. However, there may be situations in which there are several
keys, weakly certified user ID fields, or where no matching keys can be
found.</para>
<para>In these cases, you are dropped into a menu with a list of keys
- from which you can select one. When you quit this menu, or Mutt can't
+ from which you can select one. When you quit this menu, or NeoMutt can't
find any matching keys, you are prompted for a user ID. You can, as
usually, abort this prompt using
- <literal>^G</literal>. When you do so, Mutt will return to the compose
+ <literal>^G</literal>. When you do so, NeoMutt will return to the compose
screen.</para>
<para>Once you have successfully finished the key selection, the
message will be encrypted using the selected public keys when sent
sent. Technically this is achieved by letting lines of a
<quote>flowable</quote> paragraph end in spaces except for the last
line.</para>
- <para>While for text-mode clients like Mutt it's the best way to
+ <para>While for text-mode clients like NeoMutt it's the best way to
assume only a standard 80x25 character cell terminal, it may be
desired to let the receiver decide completely how to view a
message.</para>
</sect3>
<sect3 id="ff-support">
- <title>Mutt Support</title>
- <para>Mutt only supports setting the required
+ <title>NeoMutt Support</title>
+ <para>NeoMutt only supports setting the required
<literal>format=flowed</literal> MIME parameter on outgoing messages
if the
<link linkend="text-flowed">$text_flowed</link> variable is set,
specifically it does not add the trailing spaces.</para>
<para>After editing the initial message text and before entering the
- compose menu, Mutt properly space-stuffs the message.
+ compose menu, NeoMutt properly space-stuffs the message.
<emphasis>Space-stuffing</emphasis> is required by RfC3676 defining
<literal>format=flowed</literal> and means to prepend a space
to:</para>
</listitem>
</itemizedlist>
<note>
- <para>Mutt only supports space-stuffing for the first two types of
+ <para>NeoMutt only supports space-stuffing for the first two types of
lines but not for the third: It is impossible to safely detect
whether a leading
<literal>></literal>character starts a quote or not.
- Furthermore, Mutt only applies space-stuffing
+ Furthermore, NeoMutt only applies space-stuffing
<emphasis>once</emphasis> after the initial edit is finished.</para>
</note>
<para>All leading spaces are to be removed by receiving clients to
<sect3 id="ff-editor">
<title>Editor Considerations</title>
- <para>As Mutt provides no additional features to compose
+ <para>As NeoMutt provides no additional features to compose
<literal>f=f</literal> messages, it's completely up to the user and
his editor to produce proper messages. Please consider your editor's
documentation if you intend to send
<sect3 id="ff-pager">
<title>Reformatting</title>
- <para>Mutt has some support for reformatting when viewing and
+ <para>NeoMutt has some support for reformatting when viewing and
replying to
<literal>format=flowed</literal> messages. In order to take advantage
of these,
<listitem>
<para>If
<link linkend="reflow-space-quotes">$reflow_space_quotes</link> is
- unset, mutt will still add one trailing space after all the
+ unset, NeoMutt will still add one trailing space after all the
quotes in the pager (but not when replying).</para>
</listitem>
</itemizedlist>
<emphasis>compose</emphasis> menu, the body of your message and
attachments are stored in the mailbox specified by the
<link linkend="postponed">$postponed</link> variable. This means that you
- can recall the message even if you exit Mutt and then restart it at a
+ can recall the message even if you exit NeoMutt and then restart it at a
later time.</para>
<para>Once a message is postponed, there are several ways to resume it.
From the command line you can use the
<sect1 id="configuration-files">
<title>Location of Initialization Files</title>
- <para>When Mutt starts up it looks for two configuration files -- one
+ <para>When NeoMutt starts up it looks for two configuration files -- one
<quote>system</quote> file and one
<quote>user</quote> file.</para>
- <para>Mutt searches for several different file names when looking for
- config. It looks for NeoMutt config files before Mutt config files and
+ <para>NeoMutt searches for several different file names when looking for
+ config. It looks for NeoMutt config files before NeoMutt config files and
versioned config before plain config. For example:</para>
<table id="muttrc-order">
- <title>Mutt config file search order</title>
+ <title>NeoMutt config file search order</title>
<tgroup cols="1">
<tbody>
<row>
</tbody>
</tgroup>
</table>
- <para>This allows the user to create separate Mutt and NeoMutt config
+ <para>This allows the user to create separate NeoMutt and NeoMutt config
files on the same system.</para>
<sect2 id="muttrc-system">
<title>Location of system config files</title>
- <para>Mutt will search for a system config file in a
- <literal>mutt</literal> directory in several places. First it searches
+ <para>NeoMutt will search for a system config file in a
+ <literal>neomutt</literal> directory in several places. First it searches
the locations specified in the
<literal>XDG_CONFIG_DIRS</literal> environment variable, which defaults
to
<para>The system config file will not be read if the
<quote>-n</quote> option is used on the
<link linkend="commandline">command line</link>.</para>
- <para>Mutt will read just one file, the first file it finds, from the
+ <para>NeoMutt will read just one file, the first file it finds, from the
list below.</para>
<table id="muttrc-system-files">
- <title>Mutt system config file locations</title>
+ <title>NeoMutt system config file locations</title>
<tgroup cols="2">
<thead>
<row>
</thead>
<tbody>
<row>
- <entry>/etc/xdg/mutt/neomuttrc-20170912</entry>
+ <entry>/etc/xdg/neomutt/neomuttrc-20170912</entry>
<entry>NeoMutt release version</entry>
</row>
<row>
- <entry>/etc/xdg/mutt/neomuttrc</entry>
+ <entry>/etc/xdg/neomutt/neomuttrc</entry>
</row>
<row>
- <entry>/etc/xdg/mutt/Muttrc</entry>
+ <entry>/etc/xdg/neomutt/Muttrc</entry>
<entry>Note the case of the filename</entry>
</row>
<row>
- <entry>/etc/mutt/neomuttrc-20170912</entry>
+ <entry>/etc/neomutt/neomuttrc-20170912</entry>
<entry>NeoMutt release version</entry>
</row>
<row>
- <entry>/etc/mutt/neomuttrc</entry>
+ <entry>/etc/neomutt/neomuttrc</entry>
</row>
<row>
- <entry>/etc/mutt/Muttrc</entry>
+ <entry>/etc/neomutt/Muttrc</entry>
<entry>Note the case of the filename</entry>
</row>
<row>
- <entry>/usr/share/mutt/neomuttrc-20170912</entry>
+ <entry>/usr/share/neomutt/neomuttrc-20170912</entry>
<entry>NeoMutt release version</entry>
</row>
<row>
- <entry>/usr/share/mutt/neomuttrc</entry>
+ <entry>/usr/share/neomutt/neomuttrc</entry>
</row>
<row>
- <entry>/usr/share/mutt/Muttrc</entry>
+ <entry>/usr/share/neomutt/Muttrc</entry>
<entry>Note the case of the filename</entry>
</row>
</tbody>
<sect2 id="muttrc-user">
<title>Location of user config files</title>
- <para>Mutt will search for a user config file in several places. First
+ <para>NeoMutt will search for a user config file in several places. First
it looks in the directory specified in the
<literal>XDG_CONFIG_HOME</literal> environment variable, which defaults
to
- <literal>~/.config/mutt</literal>. Next, it looks in
+ <literal>~/.config/neomutt</literal>. Next, it looks in
<literal>~</literal>(your home directory). Finally, it tries
- <literal>~/.mutt</literal>.</para>
+ <literal>~/.neomutt</literal>.</para>
<para>You may specify your own location for the user config file using
the
<quote>-F</quote> option on the
<link linkend="commandline">command line</link>.</para>
- <para>Mutt will read just one file, the first file it finds, from the
+ <para>NeoMutt will read just one file, the first file it finds, from the
list below.</para>
<table id="muttrc-user-files">
- <title>Mutt user config file locations</title>
+ <title>NeoMutt user config file locations</title>
<tgroup cols="2">
<thead>
<row>
</thead>
<tbody>
<row>
- <entry>~/.config/mutt/neomuttrc-20170912</entry>
+ <entry>~/.config/neomutt/neomuttrc-20170912</entry>
<entry>NeoMutt release version</entry>
</row>
<row>
- <entry>~/.config/mutt/neomuttrc</entry>
+ <entry>~/.config/neomutt/neomuttrc</entry>
</row>
<row>
- <entry>~/.config/mutt/muttrc</entry>
+ <entry>~/.config/neomutt/muttrc</entry>
</row>
<row>
<entry>~/.neomuttrc-20170912</entry>
<entry>~/.muttrc</entry>
</row>
<row>
- <entry>~/.mutt/neomuttrc-20170912</entry>
+ <entry>~/.neomutt/neomuttrc-20170912</entry>
<entry>NeoMutt release version</entry>
</row>
<row>
- <entry>~/.mutt/neomuttrc</entry>
+ <entry>~/.neomutt/neomuttrc</entry>
</row>
<row>
- <entry>~/.mutt/muttrc</entry>
+ <entry>~/.neomutt/muttrc</entry>
</row>
</tbody>
</tgroup>
<quote>;</quote>).</para>
<example id="ex-rc-multiple-cmds">
<title>Multiple configuration commands per line</title>
- <screen>set realname='Mutt user' ; ignore x-</screen>
+ <screen>set realname='John Smith' ; ignore x-</screen>
</example>
<para>The hash mark, or pound sign (
<quote>#</quote>), is used as a
<title>Using external command's output in configuration files</title>
<screen>my_hdr X-Operating-System: `uname -a`</screen>
</example>
- <para>Both environment variables and Mutt variables can be accessed by
+ <para>Both environment variables and NeoMutt variables can be accessed by
prepending
<quote>$</quote>to the name of the variable. For example,</para>
<example id="ex-rc-env">
<title>Using environment variables in configuration files</title>
<screen>set record=+sent_on_$HOSTNAME</screen>
</example>
- <para>will cause Mutt to save outgoing messages to a folder named
+ <para>will cause NeoMutt to save outgoing messages to a folder named
<quote>sent_on_kremvax</quote> if the environment variable
<literal>$HOSTNAME</literal> is set to
<quote>kremvax.</quote>(See
<link linkend="record">$record</link> for details.)</para>
- <para>Mutt expands the variable when it is assigned, not when it is used.
+ <para>NeoMutt expands the variable when it is assigned, not when it is used.
If the value of a variable on the right-hand side of an assignment
changes after the assignment, the variable on the left-hand side will not
be affected.</para>
- <para>The commands understood by Mutt are explained in the next
+ <para>The commands understood by NeoMutt are explained in the next
paragraphs. For a complete list, see the
<link linkend="commands">command reference</link>.</para>
<para>All configuration files are expected to be in the current locale as
specified by the
<link linkend="charset">$charset</link> variable which doesn't have a
- default value since it's determined by Mutt at startup. If a
+ default value since it's determined by NeoMutt at startup. If a
configuration file is not encoded in the same character set the
<link linkend="config-charset">$config_charset</link> variable should be
used: all lines starting with the next are recoded from
<para>These variables should be set early in a configuration file
with
<link linkend="charset">$charset</link> preceding
- <link linkend="config-charset">$config_charset</link> so Mutt knows
+ <link linkend="config-charset">$config_charset</link> so NeoMutt knows
what character set to convert to.</para>
</listitem>
<listitem>
<emphasis>not</emphasis> per configuration file.</para>
</listitem>
<listitem>
- <para>Because Mutt first recodes a line before it attempts to parse
+ <para>Because NeoMutt first recodes a line before it attempts to parse
it, a conversion introducing question marks or other characters as
part of errors (unconvertable characters, transliteration) may
introduce syntax errors or silently change the meaning of certain
</arg>
</group>
</cmdsynopsis>
- <para>Mutt supports grouping addresses logically into named groups. An
+ <para>NeoMutt supports grouping addresses logically into named groups. An
address or address pattern can appear in several groups at the same time.
These groups can be used in
<link linkend="patterns">patterns</link>(for searching, limiting and
tagging) and in hooks by using group patterns. This can be useful to
classify mail and take certain actions depending on in what groups the
- message is. For example, the mutt user's mailing list would fit into the
+ message is. For example, the NeoMutt user's mailing list would fit into the
categories
<quote>mailing list</quote> and
- <quote>mutt-related</quote>. Using
+ <quote>NeoMutt-related</quote>. Using
<link linkend="send-hook">
<literal>send-hook</literal>
</link>, the sender can be set to a dedicated one for writing mailing
- list messages, and the signature could be set to a mutt-related one for
- writing to a mutt list — for other lists, the list sender setting still
+ list messages, and the signature could be set to a NeoMutt-related one for
+ writing to a NeoMutt list — for other lists, the list sender setting still
applies but a different signature can be selected. Or, given a group only
containing recipients known to accept encrypted mail,
<quote>auto-encryption</quote> can be achieved easily.</para>
</group>
</cmdsynopsis>
<para>It's usually very cumbersome to remember or type out the address of
- someone you are communicating with. Mutt allows you to create
+ someone you are communicating with. NeoMutt allows you to create
<quote>aliases</quote> which map a short string to a full address.</para>
<note>
<para>If you want to create an alias for more than one address, you
alias muttdude me@cs.hmc.edu (Michael Elkins)
alias theguys manny, moe, jack
</screen>
- <para>Unlike other mailers, Mutt doesn't require aliases to be defined in
+ <para>Unlike other mailers, NeoMutt doesn't require aliases to be defined in
a special file. The
<command>alias</command> command can appear anywhere in a configuration
file, as long as this file is
</link>function can use only one file, the one pointed to by the
<link linkend="alias-file">$alias_file</link> variable (which is
<literal>~/.muttrc</literal> by default). This file is not special either,
- in the sense that Mutt will happily append aliases to any file, but in
+ in the sense that NeoMutt will happily append aliases to any file, but in
order for the new aliases to take effect you need to explicitly
<link linkend="source">
<command>source</command>
<example id="ex-alias-external">
<title>Configuring external alias files</title>
<screen>
-source /usr/local/share/Mutt.aliases
+source /usr/local/share/NeoMutt.aliases
source ~/.mail_aliases
set alias_file=~/.mail_aliases
</screen>
</example>
- <para>To use aliases, you merely use the alias at any place in Mutt where
- Mutt prompts for addresses, such as the
+ <para>To use aliases, you merely use the alias at any place in NeoMutt where
+ NeoMutt prompts for addresses, such as the
<emphasis>To:</emphasis>or
<emphasis>Cc:</emphasis>prompt. You can also enter aliases in your editor
at the appropriate headers if you have the
<link linkend="edit-headers">$edit_headers</link> variable set.</para>
<para>In addition, at the various address prompts, you can use the tab
character to expand a partial alias to the full alias. If there are
- multiple matches, Mutt will bring up a menu with the matching aliases. In
+ multiple matches, NeoMutt will bring up a menu with the matching aliases. In
order to be presented with the full list of aliases, you must hit tab
without a partial alias, such as at the beginning of the prompt or after
a comma denoting multiple addresses.</para>
<listitem>
<para>This is not a real menu, but is used as a fallback for all of
the other menus except for the pager and editor modes. If a key is
- not defined in another menu, Mutt will look for a binding to use in
+ not defined in another menu, NeoMutt will look for a binding to use in
this menu. This allows you to bind a key to a certain function in
multiple menus instead of having multiple
<command>bind</command> statements to accomplish the same
<term>mix</term>
<listitem>
<para>The mixmaster screen is used to select remailer options for
- outgoing messages (if Mutt is compiled with Mixmaster
+ outgoing messages (if NeoMutt is compiled with Mixmaster
support).</para>
</listitem>
</varlistentry>
<sect2 id="bind-warnings">
<title>Warnings about Duplicated Bindings</title>
- <para>Due to a limitation of Mutt, creating key bindings, or macros,
+ <para>Due to a limitation of NeoMutt, creating key bindings, or macros,
will overwrite existing mappings with similar, shorter, names.</para>
<screen>
bind index g group-reply
bind index gg first-entry</screen>
<para>In this example, the <literal>g</literal> binding will be
- overwritten and cannot be used. Newer versions of Mutt will warn the
+ overwritten and cannot be used. Newer versions of NeoMutt will warn the
user about this.</para>
<para>To avoid warnings on startup, first set the shorter binding to
<literal>noop</literal> (no operation).</para>
<para>The
<command>charset-hook</command> command defines an alias for a character
set. This is useful to properly display messages which are tagged with a
- character set name not known to Mutt.</para>
+ character set name not known to NeoMutt.</para>
<para>The
<command>iconv-hook</command> command defines a system-specific name for a
character set. This is helpful when your systems character conversion
<emphasis>not</emphasis> restored when you leave the mailbox. For
example, a command action to perform is to change the sorting method
based upon the mailbox being read:</para>
- <screen>folder-hook mutt "set sort=threads"</screen>
+ <screen>folder-hook work "set sort=threads"</screen>
<para>However, the sorting method is not restored to its previous value
when reading a different mailbox. To specify a
<emphasis>default</emphasis> command, use the pattern
<link linkend="sort">sort</link> variable to
<literal>date-sent</literal> for all folders but to
<literal>threads</literal> for all folders containing
- <quote>mutt</quote> in their name.</para>
+ <quote>work</quote> in their name.</para>
<example id="ex-folder-sorting">
<title>Setting sort method based on mailbox name</title>
<screen>
folder-hook . "set sort=date-sent"
-folder-hook mutt "set sort=threads"
+folder-hook work "set sort=threads"
</screen>
</example>
</sect1>
<para>Macros are useful when you would like a single key to perform a
series of actions. When you press
<emphasis>key</emphasis> in menu
- <emphasis>menu</emphasis>, Mutt will behave as if you had typed
+ <emphasis>menu</emphasis>, NeoMutt will behave as if you had typed
<emphasis>sequence</emphasis>. So if you have a common sequence of
commands you type, you can create a macro to execute those commands with
a single key or fewer keys.</para>
</arg>
</group>
</cmdsynopsis>
- <para>If your terminal supports color, you can spice up Mutt by creating
+ <para>If your terminal supports color, you can spice up NeoMutt by creating
your own color scheme. To define the color of an object (type of
information), you must specify both a foreground color
<emphasis>and</emphasis> a background color (it is not possible to only
messages)</para>
</listitem>
<listitem>
- <para>error (error messages printed by Mutt)</para>
+ <para>error (error messages printed by NeoMutt)</para>
</listitem>
<listitem>
<para>hdrdefault (default color of the message header in the
<literal>brightred</literal>).</para>
<para>If your terminal supports it, the special keyword
<emphasis>default</emphasis> can be used as a transparent color. The value
- <emphasis>brightdefault</emphasis> is also valid. If Mutt is linked
+ <emphasis>brightdefault</emphasis> is also valid. If NeoMutt is linked
against the
<emphasis>S-Lang</emphasis> library, you also need to set the
<literal>$COLORFGBG</literal> environment variable to the default colors
<quote>*</quote>is a special token which means to clear the color list
of all entries.</para>
</note>
- <para>Mutt also recognizes the keywords
+ <para>NeoMutt also recognizes the keywords
<emphasis>color0</emphasis>,
<emphasis>color1</emphasis>, ...,
<emphasis>color</emphasis>
<sect2 id="hdr-folding">
<title>Header Display</title>
- <para>When displaying a message in the pager, Mutt folds long header
+ <para>When displaying a message in the pager, NeoMutt folds long header
lines at
<link linkend="wrap">$wrap</link> columns. Though there're precise rules
- about where to break and how, Mutt always folds headers using a tab for
- readability. (Note that the sending side is not affected by this, Mutt
+ about where to break and how, NeoMutt always folds headers using a tab for
+ readability. (Note that the sending side is not affected by this, NeoMutt
tries to implement standards compliant folding.)</para>
</sect2>
<quote>ignore *</quote>will ignore all headers.</para>
<para>To remove a previously added token from the list, use the
<quote>unignore</quote> command. The
- <quote>unignore</quote> command will make Mutt display headers with the
+ <quote>unignore</quote> command will make NeoMutt display headers with the
given pattern. For example, if you do
<quote>ignore x-</quote>it is possible to
<quote>unignore x-mailer</quote>.</para>
</cmdsynopsis>
<para>With the
<command>hdr_order</command> command you can specify an order in which
- Mutt will attempt to present these headers to you when viewing
+ NeoMutt will attempt to present these headers to you when viewing
messages.</para>
<para>
<quote>
</arg>
</group>
</cmdsynopsis>
- <para>With various functions, Mutt will treat messages differently,
+ <para>With various functions, NeoMutt will treat messages differently,
depending on whether you sent them or whether you received them from
someone else. For instance, when replying to a message that you sent to a
- different party, Mutt will automatically suggest to send the response to
+ different party, NeoMutt will automatically suggest to send the response to
the original message's recipients — responding to yourself won't make
much sense in many cases. (See
<link linkend="reply-to">$reply_to</link>.)</para>
<para>Many users receive e-mail under a number of different addresses. To
- fully use Mutt's features here, the program must be able to recognize
+ fully use NeoMutt's features here, the program must be able to recognize
what e-mail addresses you receive mail under. That's the purpose of the
<command>alternates</command> command: It takes a list of regular
expressions, each of which can identify an address under which you
precise as possible to avoid mismatches. For example, if you
specify:</para>
<screen>alternates user@example</screen>
- <para>Mutt will consider
+ <para>NeoMutt will consider
<quote>
<literal>some-user@example</literal>
</quote>as being your address, too which may not be desired. As a
</arg>
</group>
</cmdsynopsis>
- <para>Mutt has a few nice features for
+ <para>NeoMutt has a few nice features for
<link linkend="using-lists">handling mailing lists</link>. In order to
take advantage of them, you must specify which addresses belong to
- mailing lists, and which mailing lists you are subscribed to. Mutt also
+ mailing lists, and which mailing lists you are subscribed to. NeoMutt also
has limited support for auto-detecting mailing lists: it supports parsing
<literal>mailto:</literal>links in the common
<literal>List-Post:</literal>header which has the same effect as
<link linkend="list-reply">
<literal><list-reply></literal>
</link>function will work for all known lists. Additionally, when you
- send a message to a subscribed list, Mutt will add a Mail-Followup-To
+ send a message to a subscribed list, NeoMutt will add a Mail-Followup-To
header to tell other users' mail user agents not to send copies of
replies to your personal address.</para>
<note>
since it's common practice on some mailing lists to send Cc upon
replies (which is more a group- than a list-reply).</para>
</note>
- <para>More precisely, Mutt maintains lists of patterns for the addresses
+ <para>More precisely, NeoMutt maintains lists of patterns for the addresses
of known and subscribed mailing lists. Every subscribed mailing list is
known. To mark a mailing list as known, use the
<command>list</command> command. To mark it as subscribed, use
<para>as it's often sufficient to just give a portion of the list's
e-mail address.</para>
<para>Specify as much of the address as you need to to remove ambiguity.
- For example, if you've subscribed to the Mutt mailing list, you will
+ For example, if you've subscribed to the NeoMutt mailing list, you will
receive mail addressed to
- <literal>mutt-users@mutt.org</literal>. So, to tell Mutt that this is a
+ <literal>neomutt-users@neomutt.org</literal>. So, to tell NeoMutt that this is a
mailing list, you could add
- <literal>lists mutt-users@</literal>to your initialization file. To tell
- Mutt that you are subscribed to it, add
+ <literal>lists neomutt-users@</literal>to your initialization file. To tell
+ NeoMutt that you are subscribed to it, add
<literal>
- <command>subscribe</command> mutt-users</literal> to your initialization
+ <command>subscribe</command> neomutt-users</literal> to your initialization
file instead. If you also happen to get mail from someone whose address
is
- <literal>mutt-users@example.com</literal>, you could use
+ <literal>neomutt-users@example.com</literal>, you could use
<literal>
- <command>lists</command>^mutt-users@mutt\\.org$</literal>or
+ <command>lists</command> ^neomutt-users@neomutt\\.org$</literal>or
<literal>
- <command>subscribe</command>^mutt-users@mutt\\.org$</literal>to match
+ <command>subscribe</command> ^neomutt-users@neomutt\\.org$</literal>to match
only mail from the actual list.</para>
<para>The
<literal>-group</literal> flag adds all of the subsequent regular
will be checked for new messages periodically.</para>
<para>
<emphasis>folder</emphasis> can either be a local file or directory
- (Mbox/Mmdf or Maildir/Mh). If Mutt was built with POP and/or IMAP
+ (Mbox/Mmdf or Maildir/Mh). If NeoMutt was built with POP and/or IMAP
support,
<emphasis>folder</emphasis> can also be a POP/IMAP folder URL. The URL
syntax is described in
<xref linkend="url-syntax" />, POP and IMAP are described in
<xref linkend="pop" />and
<xref linkend="imap" />respectively.</para>
- <para>Mutt provides a number of advanced features for handling (possibly
+ <para>NeoMutt provides a number of advanced features for handling (possibly
many) folders and new mail within them, please refer to
<xref linkend="new-mail" />for details (including in what situations and
- how often Mutt checks for new mail).</para>
+ how often NeoMutt checks for new mail).</para>
<para>The
<quote>unmailboxes</quote> command is used to remove a token from the list
of folders which receive mail. Use
<link linkend="folder">$folder</link> and
<link linkend="spoolfile">$spoolfile</link>) should be set before the
<command>mailboxes</command> command. If none of these shortcuts are
- used, a local path should be absolute as otherwise Mutt tries to find
- it relative to the directory from where Mutt was started which may not
+ used, a local path should be absolute as otherwise NeoMutt tries to find
+ it relative to the directory from where NeoMutt was started which may not
always be desired.</para>
</note>
</sect1>
<para>Space characters are
<emphasis>not</emphasis> allowed between the keyword and the colon (
<quote>:</quote>). The standard for electronic mail (RFC2822) says that
- space is illegal there, so Mutt enforces the rule.</para>
+ space is illegal there, so NeoMutt enforces the rule.</para>
</note>
<para>If you would like to add a header field to a single message, you
should either set the
<emphasis>pattern</emphasis>, see
<xref linkend="pattern-hook" />for information on the exact
format.</para>
- <para>To provide more flexibility and good defaults, Mutt applies the
+ <para>To provide more flexibility and good defaults, NeoMutt applies the
expandos of
<link linkend="index-format">$index_format</link> to
<emphasis>mailbox</emphasis> after it was expanded.</para>
</arg>
</cmdsynopsis>
<para>This command is used to save outgoing mail in a mailbox other than
- <link linkend="record">$record</link>. Mutt searches the initial list of
+ <link linkend="record">$record</link>. NeoMutt searches the initial list of
message recipients for the first matching
<emphasis>pattern</emphasis> and uses
<emphasis>mailbox</emphasis> as the default Fcc: mailbox. If no match is
found the message will be saved to
<link linkend="record">$record</link> mailbox.</para>
- <para>To provide more flexibility and good defaults, Mutt applies the
+ <para>To provide more flexibility and good defaults, NeoMutt applies the
expandos of
<link linkend="index-format">$index_format</link> to
<emphasis>mailbox</emphasis> after it was expanded.</para>
<literal>.muttrc</literal>(for that type of hook).</para>
<para>Example:
<literal>
- <command>send-hook</command> mutt "
+ <command>send-hook</command> work "
<command>set</command> mime_forward signature=''"</literal></para>
<para>Another typical use for this command is to change the values of the
<link linkend="attribution">$attribution</link>,
<para>When encrypting messages with PGP/GnuPG or OpenSSL, you may want to
associate a certain key with a given e-mail address automatically, either
because the recipient's public key can't be deduced from the destination
- address, or because, for some reasons, you need to override the key Mutt
+ address, or because, for some reasons, you need to override the key NeoMutt
would normally use. The
<command>crypt-hook</command> command provides a method by which you can
specify the ID of the public key to be used when encrypting messages to a
certain recipient. You may use multiple crypt-hooks with the same regexp;
multiple matching crypt-hooks result in the use of multiple keyids for a
- recipient. During key selection, Mutt will confirm whether each
+ recipient. During key selection, NeoMutt will confirm whether each
crypt-hook is to be used (unless the
<link linkend="crypt-confirmhook">$crypt_confirmhook</link> option is
- unset). If all crypt-hooks for a recipient are declined, Mutt will use
+ unset). If all crypt-hooks for a recipient are declined, NeoMutt will use
the original recipient address for key selection instead.</para>
<para>The meaning of
<emphasis>keyid</emphasis> is to be taken broadly in this context: You can
<para>For using functions like shown in the example, it's important to
use angle brackets (
<quote><</quote>and
- <quote>></quote>) to make Mutt recognize the input as a function name.
+ <quote>></quote>) to make NeoMutt recognize the input as a function name.
Otherwise it will simulate individual just keystrokes, i.e.
<quote>
<literal>push collapse-all</literal>
</arg>
</group>
</cmdsynopsis>
- <para>Mutt has generalized support for external spam-scoring filters. By
+ <para>NeoMutt has generalized support for external spam-scoring filters. By
defining your spam patterns with the
<command>spam</command> and
<literal>nospam</literal> commands, you can
<literal>%1</literal> is replaced with the first back-reference in the
regex,
<literal>%2</literal> with the second, etc.</para>
- <para>To match spam tags, mutt needs the corresponding header information
+ <para>To match spam tags, NeoMutt needs the corresponding header information
which is always the case for local and POP folders but not for IMAP in
the default configuration. Depending on the spam header to be analyzed,
<link linkend="imap-headers">$imap_headers</link> may need to be
attribute will use as a sort key.</para>
<para>That's a pretty complicated example, and most people's actual
environments will have only one spam filter. The simpler your
- configuration, the more effective Mutt can be, especially when it comes
+ configuration, the more effective NeoMutt can be, especially when it comes
to sorting.</para>
- <para>Generally, when you sort by spam tag, Mutt will sort
+ <para>Generally, when you sort by spam tag, NeoMutt will sort
<emphasis>lexically</emphasis>— that is, by ordering strings
- alphanumerically. However, if a spam tag begins with a number, Mutt will
+ alphanumerically. However, if a spam tag begins with a number, NeoMutt will
sort numerically first, and lexically only when two numbers are equal in
value. (This is like UNIX's
<literal>sort -n</literal>.) A message with no spam attributes at all —
<quote>a</quote> taking lower priority than
<quote>z</quote>. Clearly, in general, sorting by spam tags is most
effective when you can coerce your filter to give you a raw number. But
- in case you can't, Mutt can still do something useful.</para>
+ in case you can't, NeoMutt can still do something useful.</para>
<para>The
<command>nospam</command> command can be used to write exceptions to
<command>spam</command> patterns. If a header pattern matches something in
<command>spam</command> or
<command>nospam</command> commands as you like. You can even do your own
primitive
- <command>spam</command> detection within Mutt — for example, if you
+ <command>spam</command> detection within NeoMutt — for example, if you
consider all mail from
<literal>MAILER-DAEMON</literal> to be spam, you can use a
<command>spam</command> command like this:</para>
<sect2 id="var-types">
<title>Variable Types</title>
- <para>Mutt supports these types of configuration variables:</para>
+ <para>NeoMutt supports these types of configuration variables:</para>
<variablelist>
<varlistentry>
<term>boolean</term>
<sect3 id="set-myvar-intro">
<title>Introduction</title>
<para>Along with the variables listed in the
- <link linkend="variables">Configuration variables</link> section, Mutt
+ <link linkend="variables">Configuration variables</link> section, NeoMutt
supports user-defined variables with names starting with
<literal>my_</literal> as in, for example,
<literal>my_cfgdir</literal>.</para>
<title>Using user-defined variables for config file
readability</title>
<screen>
-set my_cfgdir = $HOME/mutt/config
+set my_cfgdir = $HOME/neomutt/config
source $my_cfgdir/hooks $my_cfgdir/macros
<emphasis role="comment"># more source commands...</emphasis>
</screen>
<enter-command>set delete=$my_delete<enter>'
</screen>
</example>
- <para>Since Mutt expands such values already when parsing the
+ <para>Since NeoMutt expands such values already when parsing the
configuration file(s), the value of
<literal>$my_delete</literal> in the last example would be the value
of
</example>
<para>Note that there is a space between
<literal><enter-command></literal>and the
- <command>set</command> configuration command, preventing Mutt from
+ <command>set</command> configuration command, preventing NeoMutt from
recording the
<command>macro</command>'s commands into its history.</para>
</sect3>
<sect2 id="set-conversions">
<title>Type Conversions</title>
- <para>Variables are always assigned string values which Mutt parses
+ <para>Variables are always assigned string values which NeoMutt parses
into its internal representation according to the type of the variable,
for example an integer number for numeric types. For all queries
(including $-expansion) the value is converted from its internal type
back into string. As a result, any variable can be assigned any value
given that its content is valid for the target. This also counts for
custom variables which are of type string. In case of parsing errors,
- Mutt will print error messages.
+ NeoMutt will print error messages.
<xref linkend="ex-myvar4" />demonstrates type conversions.</para>
<example id="ex-myvar4">
<title>Type conversions using variables</title>
<sect2 id="formatstrings-basics">
<title>Basic usage</title>
<para>Format strings are a general concept you'll find in several
- locations through the Mutt configuration, especially in the
+ locations through the NeoMutt configuration, especially in the
<link linkend="index-format">$index_format</link>,
<link linkend="pager-format">$pager_format</link>,
<link linkend="status-format">$status_format</link>, and other related
<literal>%4c</literal>,
<literal>%.15F</literal> and
<literal>%-12.15L</literal>.</para>
- <para>Mutt adds some other modifiers to format strings. If you use an
+ <para>NeoMutt adds some other modifiers to format strings. If you use an
equals symbol (
<literal>=</literal>) as a numeric prefix (like the minus above), it
will force the string to be centered within its minimum space range.
<title>Using external filters in format strings</title>
<screen>set status_format="script.sh '%r %f (%L)'|"</screen>
</example>
- <para>will make Mutt expand
+ <para>will make NeoMutt expand
<literal>%r</literal>,
<literal>%f</literal> and
<literal>%L</literal> before calling the script. The example also shows
string between the single quotes as the only argument.</para>
<para>A practical example is the
<literal>mutt_xtitle</literal> script installed in the
- <literal>samples</literal> subdirectory of the Mutt documentation: it
+ <literal>samples</literal> subdirectory of the NeoMutt documentation: it
can be used as filter for
<link linkend="status-format">$status_format</link> to set the current
terminal's title, if supported.</para>
<sect2 id="formatstrings-padding">
<title>Padding</title>
- <para>In most format strings, Mutt supports different types of padding
+ <para>In most format strings, NeoMutt supports different types of padding
using special %-expandos:</para>
<variablelist>
<varlistentry>
<literal>%|X</literal>
</term>
<listitem>
- <para>When this occurs, Mutt will fill the rest of the line with
+ <para>When this occurs, NeoMutt will fill the rest of the line with
the character
<literal>X</literal>. For example, filling the rest of the line
with dashes is done by setting:</para>
</arg>
</group>
</cmdsynopsis>
- <para>As a security measure, Mutt will only add user-approved header
+ <para>As a security measure, NeoMutt will only add user-approved header
fields from a
- <literal>mailto:</literal>URL. This is necessary since Mutt will handle
+ <literal>mailto:</literal>URL. This is necessary since NeoMutt will handle
certain header fields, such as
<literal>Attach:</literal>, in a special way. The
<literal>mailto_allow</literal> and
<literal>unmailto_allow</literal> commands allow the user to modify the
list of approved headers.</para>
- <para>Mutt initializes the default list to contain only the
+ <para>NeoMutt initializes the default list to contain only the
<literal>Subject</literal> and
<literal>Body</literal> header fields, which are the only requirement
specified by the
is used. For the Unicode character set, different character encodings may
be used, UTF-8 being the most popular. In UTF-8, a character is
represented using a variable number of bytes ranging from 1 to 4.</para>
- <para>Since Mutt is a command-line tool run from a shell, and delegates
+ <para>Since NeoMutt is a command-line tool run from a shell, and delegates
certain tasks to external tools (such as an editor for composing/editing
messages), all of these tools need to agree on a character set and
encoding. There exists no way to reliably deduce the character set a
well-defined environment variables. The full set can be printed by
issuing
<literal>locale</literal> on the command line.</para>
- <para>Upon startup, Mutt determines the character set on its own using
+ <para>Upon startup, NeoMutt determines the character set on its own using
routines that inspect locale-specific environment variables. Therefore,
it is generally not necessary to set the
- <literal>$charset</literal> variable in Mutt. It may even be
- counter-productive as Mutt uses system and library functions that derive
- the character set themselves and on which Mutt has no influence. It's
- safest to let Mutt work out the locale setup itself.</para>
+ <literal>$charset</literal> variable in NeoMutt. It may even be
+ counter-productive as NeoMutt uses system and library functions that derive
+ the character set themselves and on which NeoMutt has no influence. It's
+ safest to let NeoMutt work out the locale setup itself.</para>
<para>If you happen to work with several character sets on a regular
basis, it's highly advisable to use Unicode and an UTF-8 locale. Unicode
can represent nearly all characters in a message at the same time. When
be guessed).</para>
<para>A Unicode locale makes all conversions superfluous which eliminates
the risk of conversion errors. It also eliminates potentially wrong
- expectations about the character set between Mutt and external
+ expectations about the character set between NeoMutt and external
programs.</para>
<para>The terminal emulator used also must be properly configured for the
current locale. Terminal emulators usually do
<emphasis>not</emphasis> derive the locale from environment variables,
they need to be configured separately. If the terminal is incorrectly
- configured, Mutt may display random and unexpected characters (question
+ configured, NeoMutt may display random and unexpected characters (question
marks, octal codes, or just random glyphs), format strings may not work
as expected, you may not be abled to enter non-ascii characters, and
possible more. Data is always represented using bytes and so a correct
setup is very important as to the machine, all character sets
<quote>look</quote> the same.</para>
<para>Warning: A mismatch between what system and library functions think
- the locale is and what Mutt was told what the locale is may make it
+ the locale is and what NeoMutt was told what the locale is may make it
behave badly with non-ascii input: it will fail at seemingly random
places. This warning is to be taken seriously since not only local mail
handling may suffer: sent messages may carry wrong character set
information the
<emphasis>receiver</emphasis> has too deal with. The need to set
<literal>$charset</literal> directly in most cases points at terminal and
- environment variable setup problems, not Mutt problems.</para>
+ environment variable setup problems, not NeoMutt problems.</para>
<para>A list of officially assigned and known character sets can be found
at
<ulink url="http://www.iana.org/assignments/character-sets">IANA</ulink>,
<sect1 id="regexp">
<title>Regular Expressions</title>
- <para>All string patterns in Mutt including those in more complex
+ <para>All string patterns in NeoMutt including those in more complex
<link linkend="patterns">patterns</link> must be specified using regular
expressions (regexp) in the
<quote>POSIX extended</quote> syntax (which is more or less the syntax
precedence over alternation. A whole subexpression may be enclosed in
parentheses to override these precedence rules.</para>
<note>
- <para>If you compile Mutt with the included regular expression engine,
+ <para>If you compile NeoMutt with the included regular expression engine,
the following operators may also be used in regular expressions as
described in
<xref linkend="regex-gnu-ext" />.</para>
<sect2 id="patterns-modifier">
<title>Pattern Modifier</title>
- <para>Many of Mutt's commands allow you to specify a pattern to match (
+ <para>Many of NeoMutt's commands allow you to specify a pattern to match (
<literal>limit</literal>,
<literal>tag-pattern</literal>,
<literal>delete-pattern</literal>, etc.).
other types of ranges. Read on and see
<xref linkend="message-ranges" />below.</para>
<para>Special attention has to be paid when using regular expressions
- inside of patterns. Specifically, Mutt's parser for these patterns will
+ inside of patterns. Specifically, NeoMutt's parser for these patterns will
strip one level of backslash (
<quote>\</quote>), which is normally used for quoting. If it is your
intention to use a backslash in the regular expression, you will need
to use two backslashes instead (
- <quote>\\</quote>). You can force Mutt to treat
+ <quote>\\</quote>). You can force NeoMutt to treat
<emphasis>EXPR</emphasis> as a simple substring instead of a regular
expression by using = instead of ~ in the pattern name. For example,
<literal>=b *.*</literal>will find all messages that contain the
<sect2 id="simple-searches">
<title>Simple Searches</title>
- <para>Mutt supports two versions of so called
+ <para>NeoMutt supports two versions of so called
<quote>simple searches</quote>. These are issued if the query entered
for searching, limiting and similar operations does not seem to contain
a valid pattern modifier (i.e. it does not contain one of these
<quote>\</quote>).</para>
<para>The first type is by checking whether the query string equals a
keyword case-insensitively from
- <xref linkend="tab-simplesearch-keywords" />: If that is the case, Mutt
+ <xref linkend="tab-simplesearch-keywords" />: If that is the case, NeoMutt
will use the shown pattern modifier instead. If a keyword would
conflict with your search keyword, you need to turn it into a regular
expression to avoid matching the keyword table. For example, if you
</table>
<para>The second type of simple search is to build a complex search
pattern using
- <link linkend="simple-search">$simple_search</link> as a template. Mutt
+ <link linkend="simple-search">$simple_search</link> as a template. NeoMutt
will insert your query properly quoted and search for the composed
complex query.</para>
</sect2>
<title>Nesting and Boolean Operators</title>
<para>Logical AND is performed by specifying more than one criterion.
For example:</para>
- <screen>~t mutt ~f elkins</screen>
+ <screen>~t work ~f elkins</screen>
<para>would select messages which contain the word
- <quote>mutt</quote> in the list of recipients
+ <quote>work</quote> in the list of recipients
<emphasis>and</emphasis> that have the word
<quote>elkins</quote> in the
<quote>From</quote> header field.</para>
- <para>Mutt also recognizes the following operators to create more
+ <para>NeoMutt also recognizes the following operators to create more
complex search patterns:</para>
<itemizedlist>
<listitem>
</itemizedlist>
<para>Here is an example illustrating a complex search pattern. This
pattern will select all messages which do not contain
- <quote>mutt</quote> in the
+ <quote>work</quote> in the
<quote>To</quote> or
<quote>Cc</quote> field and which are from
<quote>elkins</quote>.</para>
<example id="ex-pattern-bool">
<title>Using boolean operators in patterns</title>
- <screen>!(~t mutt|~c mutt) ~f elkins</screen>
+ <screen>!(~t work|~c work) ~f elkins</screen>
</example>
<para>Here is an example using white space in the regular expression
(note the
("|"), you
<emphasis>must</emphasis> enclose the expression in double or single
quotes since those characters are also used to separate different
- parts of Mutt's pattern language. For example:
- <literal>~f "me@(mutt\.org|cs\.hmc\.edu)"</literal>Without the
+ parts of NeoMutt's pattern language. For example:
+ <literal>~f "user@(home\.org|work\.com)"</literal>Without the
quotes, the parenthesis wouldn't end. This would be separated to two
OR'd patterns:
- <emphasis>~f me@(mutt\.org</emphasis> and
- <emphasis>cs\.hmc\.edu)</emphasis>. They are never what you
+ <emphasis>~f user@(home\.org</emphasis> and
+ <emphasis>work\.com)</emphasis>. They are never what you
want.</para>
</note>
</sect2>
<sect2 id="date-patterns">
<title>Searching by Date</title>
- <para>Mutt supports two types of dates,
+ <para>NeoMutt supports two types of dates,
<emphasis>absolute</emphasis> and
<emphasis>relative</emphasis>.</para>
<ulink url="https://support.google.com/mail/answer/7190?hl=en">GMail's Support Page</ulink>.
You will need to (once) use a web-browser to visit Settings/Labels
and enable "Show in IMAP" for "All Mail". When searching, visit that
- folder in mutt to most closely match Gmail search semantics.
+ folder in NeoMutt to most closely match Gmail search semantics.
</para>
<table id="gmail-example-patterns">
<title>GMail Example Patterns</title>
<sect1 id="markmsg">
<title>Marking Messages</title>
- <para>There are times that it's useful to ask Mutt to "remember" which
+ <para>There are times that it's useful to ask NeoMutt to "remember" which
message you're currently looking at, while you move elsewhere in your
mailbox. You can do this with the
<quote>mark-message</quote> operator, which is bound to the
by hand using the
<literal><tag-message></literal>function, which is bound to
<quote>t</quote> by default. See
- <link linkend="patterns">patterns</link> for Mutt's pattern matching
+ <link linkend="patterns">patterns</link> for NeoMutt's pattern matching
syntax.</para>
<para>Once you have tagged the desired messages, you can use the
<quote>tag-prefix</quote> operator, which is the
<command>push</command>
</link>commands, you can use the
<literal><tag-prefix-cond></literal>operator. If there are no
- tagged messages, Mutt will
- <quote>eat</quote> the rest of the macro to abort it's execution. Mutt
+ tagged messages, NeoMutt will
+ <quote>eat</quote> the rest of the macro to abort it's execution. NeoMutt
will stop
<quote>eating</quote> the macro when it encounters the
<literal><end-cond></literal>operator; after this operator the rest
allows you to execute arbitrary commands before performing some
operation. For example, you may wish to tailor your configuration based
upon which mailbox you are reading, or to whom you are sending mail. In
- the Mutt world, a
+ the NeoMutt world, a
<emphasis>hook</emphasis> consists of a
<link linkend="regexp">regular expression</link> or
<link linkend="patterns">pattern</link> along with a configuration
<emphasis>hook</emphasis> available.</para>
<note>
<para>If a hook changes configuration settings, these changes remain
- effective until the end of the current Mutt session. As this is
+ effective until the end of the current NeoMutt session. As this is
generally not desired, a
<quote>default</quote> hook needs to be added before all other hooks of
that type to restore configuration defaults.</para>
dealing with messages a finer grain of control is needed for matching
since for different purposes you want to match different
criteria.</para>
- <para>Mutt allows the use of the
+ <para>NeoMutt allows the use of the
<link linkend="patterns">search pattern</link> language for matching
messages in hook commands. This works in exactly the same way as it
would when
<emphasis>limiting</emphasis> or
<emphasis>searching</emphasis> the mailbox, except that you are
- restricted to those operators which match information Mutt extracts
+ restricted to those operators which match information NeoMutt extracts
from the header of the message (i.e., from, to, cc, date, subject,
etc.).</para>
<para>For example, if you wanted to set your return address based upon
sending mail to a specific address, you could do something like:</para>
- <screen>send-hook '~t ^me@cs\.hmc\.edu$' 'my_hdr From: Mutt User <user@host>'</screen>
+ <screen>send-hook '~t ^user@work\.com$' 'my_hdr From: John Smith <user@host>'</screen>
<para>which would execute the given command when sending mail to
- <emphasis>me@cs.hmc.edu</emphasis>.</para>
+ <emphasis>user@work.com</emphasis>.</para>
<para>However, it is not required that you write the pattern to match
using the full searching language. You can still specify a simple
<emphasis>regular expression</emphasis> like the other hooks, in which
- case Mutt will translate your pattern into the full language, using the
+ case NeoMutt will translate your pattern into the full language, using the
translation specified by the
<link linkend="default-hook">$default_hook</link> variable. The pattern
is translated at the time the hook is declared, so the value of
</screen>
<para>Keep in mind that mailbox shortcut expansion on the regexp
parameter takes place when the hook is initially parsed, not when the
- hook is matching against a mailbox. When Mutt starts up and is reading
+ hook is matching against a mailbox. When NeoMutt starts up and is reading
the .muttrc, some mailbox shortcuts may not be usable. For example, the
"current mailbox" shortcut, ^, will expand to an empty string because
- no mailbox has been opened yet. Mutt will issue an error for this case
+ no mailbox has been opened yet. NeoMutt will issue an error for this case
or if the mailbox shortcut results in an empty regexp.</para>
</sect2>
</sect1>
<sect1 id="setenv">
<title>Managing the Environment</title>
- <para>You can alter the environment that Mutt passes on to its child
+ <para>You can alter the environment that NeoMutt passes on to its child
processes using the
<quote>setenv</quote> and
- <quote>unsetenv</quote> operators. (N.B. These follow Mutt-style syntax,
+ <quote>unsetenv</quote> operators. (N.B. These follow NeoMutt-style syntax,
not shell-style!) You can also query current environment values by
prefixing a
<quote>?</quote>character.</para>
<screen>
setenv TERM vt100
-setenv ORGANIZATION "The Mutt Development Team"
+setenv ORGANIZATION "The NeoMutt Development Team"
unsetenv DISPLAY
setenv ?LESS
</screen>
<sect1 id="query">
<title>External Address Queries</title>
- <para>Mutt supports connecting to external directory databases such as
- LDAP, ph/qi, bbdb, or NIS through a wrapper script which connects to Mutt
+ <para>NeoMutt supports connecting to external directory databases such as
+ LDAP, ph/qi, bbdb, or NIS through a wrapper script which connects to NeoMutt
using a simple interface. Using the
<link linkend="query-command">$query_command</link> variable, you specify
the wrapper command to use. For example:</para>
blong@fiction.net Brandon Long mutt and more
roessler@does-not-exist.org Thomas Roessler mutt pgp
</screen>
- <para>There are two mechanisms for accessing the query function of Mutt.
+ <para>There are two mechanisms for accessing the query function of NeoMutt.
One is to do a query from the index menu using the
<literal><query></literal>function (default: Q). This will prompt
for a query, then bring up the query menu which will list the matching
completion, similar to the alias completion. In any prompt for address
entry, you can use the
<literal><complete-query></literal>function (default: ^T) to run a
- query based on the current address you have typed. Like aliases, Mutt
+ query based on the current address you have typed. Like aliases, NeoMutt
will look for what you have typed back to the last space or comma. If
- there is a single response for that query, Mutt will expand the address
- in place. If there are multiple responses, Mutt will activate the query
+ there is a single response for that query, NeoMutt will expand the address
+ in place. If there are multiple responses, NeoMutt will activate the query
menu. At the query menu, you can select one or more addresses to be added
to the prompt.</para>
</sect1>
<sect1 id="mailbox-formats">
<title>Mailbox Formats</title>
- <para>Mutt supports reading and writing of four different local mailbox
+ <para>NeoMutt supports reading and writing of four different local mailbox
formats: mbox, MMDF, MH and Maildir. The mailbox type is auto detected,
so there is no need to use a flag for different mailbox types. When
- creating new mailboxes, Mutt uses the default specified with the
+ creating new mailboxes, NeoMutt uses the default specified with the
<link linkend="mbox-type">$mbox_type</link> variable. A short description
of the formats follows.</para>
<para>
<emphasis>mbox</emphasis> and
<emphasis>MMDF</emphasis>, a mailbox consists of a directory and each
message is stored in a separate file. The filename indicates the message
- number (however, this is may not correspond to the message number Mutt
+ number (however, this is may not correspond to the message number NeoMutt
displays). Deleted messages are renamed with a comma (
- <quote>,</quote>) prepended to the filename. Mutt detects this type of
+ <quote>,</quote>) prepended to the filename. NeoMutt detects this type of
mailbox by looking for either
<literal>.mh_sequences</literal> or
<literal>.xmhcache</literal> files (needed to distinguish normal
writing the mailbox, but still may suffer from lost flags; message
corruption is less likely to occur than with mbox/mmdf. It's usually
slower to open compared to mbox/mmdf since many small files have to be
- read (Mutt provides
+ read (NeoMutt provides
<xref linkend="header-caching" />to greatly speed this process up).
Depending on the environment, MH is not very disk-space efficient.</para>
<para>
<emphasis>cur</emphasis>. Filenames for the messages are chosen in such a
way they are unique, even when two programs are writing the mailbox over
NFS, which means that no file locking is needed and corruption is very
- unlikely. Maildir maybe slower to open without caching in Mutt, it too is
+ unlikely. Maildir maybe slower to open without caching in NeoMutt, it too is
not very disk-space efficient depending on the environment. Since no
additional files are used for metadata (which is embedded in the message
filenames) and Maildir is locking-free, it's easy to sync across
<sect1 id="using-lists">
<title>Handling Mailing Lists</title>
- <para>Mutt has a few configuration options that make dealing with large
- amounts of mail easier. The first thing you must do is to let Mutt know
+ <para>NeoMutt has a few configuration options that make dealing with large
+ amounts of mail easier. The first thing you must do is to let NeoMutt know
what addresses you consider to be mailing lists (technically this does
not have to be a mailing list, but that is what it is most often used
for), and what lists you are subscribed to. This is accomplished through
<command>lists</command> and
<command>subscribe</command></link>commands in your
<literal>.muttrc</literal>.</para>
- <para>Now that Mutt knows what your mailing lists are, it can do several
+ <para>Now that NeoMutt knows what your mailing lists are, it can do several
things, the first of which is the ability to show the name of a list
through which you received a message (i.e., of a subscribed list) in the
<emphasis>index</emphasis> menu display. This is useful to distinguish
the known mailing list addresses instead of all recipients (except as
specified by
<literal>Mail-Followup-To</literal>, see below).</para>
- <para>Mutt also supports the
+ <para>NeoMutt also supports the
<literal>Mail-Followup-To</literal> header. When you send a message to a
list of recipients which includes one or several subscribed mailing
lists, and if the
- <link linkend="followup-to">$followup_to</link> option is set, Mutt will
+ <link linkend="followup-to">$followup_to</link> option is set, NeoMutt will
generate a Mail-Followup-To header which contains all the recipients to
whom you send this message, but not your address. This indicates that
group-replies or list-replies (also known as
to.</para>
<para>Conversely, when group-replying or list-replying to a message which
has a
- <literal>Mail-Followup-To</literal> header, Mutt will respect this header
+ <literal>Mail-Followup-To</literal> header, NeoMutt will respect this header
if the
<link linkend="honor-followup-to">$honor_followup_to</link> configuration
variable is set. Using
<literal>Mail-Followup-To</literal>.</para>
<note>
<para>When header editing is enabled, you can create a
- <literal>Mail-Followup-To</literal> header manually. Mutt will only
+ <literal>Mail-Followup-To</literal> header manually. NeoMutt will only
auto-generate this header if it doesn't exist when you send the
message.</para>
</note>
address rather than the author of the message. This can create problems
when trying to reply directly to the author in private, since most mail
clients will automatically reply to the address given in the
- <quote>Reply-To</quote> field. Mutt uses the
+ <quote>Reply-To</quote> field. NeoMutt uses the
<link linkend="reply-to">$reply_to</link> variable to help decide which
address to use. If set to
<emphasis>ask-yes</emphasis> or
<emphasis>yes</emphasis>, the
<quote>Reply-To</quote> field will be used when present.</para>
<para>You can change or delete the
- <quote>X-Label:</quote>field within Mutt using the
+ <quote>X-Label:</quote>field within NeoMutt using the
<quote>edit-label</quote> command, bound to the
<quote>y</quote> key by default. This works for tagged messages, too.
While in the edit-label function, pressing the <complete> binding
(TAB, by default) will perform completion against all labels currently in
use.</para>
- <para>Lastly, Mutt has the ability to
+ <para>Lastly, NeoMutt has the ability to
<link linkend="sort">sort</link> the mailbox into
<link linkend="threads">threads</link>. A thread is a group of messages
which all relate to the same subject. This is usually organized into a
<sect1 id="using-keywords">
<title>Keyword Management</title>
- <para>Mutt has supported textual labels (usually known as X-Labels after
+ <para>NeoMutt has supported textual labels (usually known as X-Labels after
the header that we use to store them) for many years. Since we initially
added support for X-Labels, however, the larger community has evolved
more common ways of using and managing such labels, often known as
<quote>keywords</quote> or
<quote>tags</quote>.</para>
- <para>If you are new to Mutt or to using keywords in Mutt, you only need
+ <para>If you are new to NeoMutt or to using keywords in NeoMutt, you only need
to know that the <edit-label> binding will edit keywords, and that
you can search for keywords using the
<literal>~y</literal> pattern, and use the
that you set will be stored to the
<literal>X-Label:</literal>header by default.</para>
<para>If you've been using X-Labels for a while, things have grown
- slightly. Mutt still supports X-Labels much as it has since 2000, but the
+ slightly. NeoMutt still supports X-Labels much as it has since 2000, but the
scope of this support has expanded to support three additional
header-based techniques for storing keyword metadata on messages:</para>
<variablelist>
<varlistentry>
<term>X-Label</term>
<listitem>
- <para>Mutt-specific design; freeform text (but see
+ <para>NeoMutt-specific design; freeform text (but see
<link linkend="xlabel-delimiter">$xlabel_delimiter</link>)</para>
</listitem>
</varlistentry>
</variablelist>
- <para>With X-Label, mutt's only notion of a message keyword was the
+ <para>With X-Label, NeoMutt's only notion of a message keyword was the
literal string value of the X-Label header. Under the new, integrated
support, each message may have a list of distinct message keywords. When
reading keywords from one of the headers in the list above, the header
splitting of X-Label: as well.</para>
<para>Two boolean variables control how keywords are saved when writing
messages to a mailbox. The default settings preserve backward
- compatibility within mutt completely, but by changing these values you
+ compatibility within NeoMutt completely, but by changing these values you
can transition to more standard keyword storage.
<link linkend="keywords-legacy">$keywords_legacy</link>, if set, will
- tell mutt to use only "legacy" headers -- i.e.,
+ tell NeoMutt to use only "legacy" headers -- i.e.,
<literal>X-Keywords:</literal>,
<literal>X-Mozilla-Keys</literal>,
<literal>Keywords</literal>, or
<sect1 id="new-mail">
<title>New Mail Detection</title>
- <para>Mutt supports setups with multiple folders, allowing all of them to
+ <para>NeoMutt supports setups with multiple folders, allowing all of them to
be monitored for new mail (see
<xref linkend="mailboxes" />for details).</para>
<sect2 id="new-mail-formats">
<title>How New Mail Detection Works</title>
<para>For Mbox and Mmdf folders, new mail is detected by comparing
- access and/or modification times of files: Mutt assumes a folder has
+ access and/or modification times of files: NeoMutt assumes a folder has
new mail if it wasn't accessed after it was last modified. Utilities
like
<literal>biff</literal> or
<literal>frm</literal> or any other program which accesses the mailbox
- might cause Mutt to never detect new mail for that mailbox if they do
- not properly reset the access time. Other possible causes of Mutt not
+ might cause NeoMutt to never detect new mail for that mailbox if they do
+ not properly reset the access time. Other possible causes of NeoMutt not
detecting new mail in these folders are backup tools (updating access
times) or filesystems mounted without access time update support (for
Linux systems, see the
<literal>relatime</literal> option).</para>
<note>
- <para>Contrary to older Mutt releases, it now maintains the new mail
+ <para>Contrary to older NeoMutt releases, it now maintains the new mail
status of a folder by properly resetting the access time if the
folder contains at least one message which is neither read, nor
deleted, nor marked as old.</para>
<para>In cases where new mail detection for Mbox or Mmdf folders
appears to be unreliable, the
<link linkend="check-mbox-size">$check_mbox_size</link> option can be
- used to make Mutt track and consult file sizes for new mail detection
+ used to make NeoMutt track and consult file sizes for new mail detection
instead which won't work for size-neutral changes.</para>
<para>New mail for Maildir is assumed if there is one message in the
<literal>new/</literal>subdirectory which is not marked deleted (see
<link linkend="new-mail-command">$new_mail_command</link> can be
configured to execute an external program every time new mail is
detected in the current inbox.</para>
- <para>Mutt does not poll POP3 folders for new mail, it only
+ <para>NeoMutt does not poll POP3 folders for new mail, it only
periodically checks the currently opened folder (if it's a POP3
folder).</para>
- <para>For IMAP, by default Mutt uses recent message counts provided by
+ <para>For IMAP, by default NeoMutt uses recent message counts provided by
the server to detect new mail. If the
<link linkend="imap-idle">$imap_idle</link> option is set, it'll use the
IMAP IDLE extension if advertised by the server.</para>
<para>The
<link linkend="mail-check-recent">$mail_check_recent</link> option
- changes whether Mutt will notify you of new mail in an already visited
+ changes whether NeoMutt will notify you of new mail in an already visited
mailbox. When set (the default) it will only notify you of new mail
- received since the last time you opened the mailbox. When unset, Mutt
+ received since the last time you opened the mailbox. When unset, NeoMutt
will notify you of any new mail in the mailbox.</para>
</sect2>
<sect2 id="new-mail-polling">
<title>Polling For New Mail</title>
<para>When in the index menu and being idle (also see
- <link linkend="timeout">$timeout</link>), Mutt periodically checks for
+ <link linkend="timeout">$timeout</link>), NeoMutt periodically checks for
new mail in all folders which have been configured via the
<command>mailboxes</command> command. The interval depends on the folder
type: for local/IMAP folders it consults
default. Pressing TAB will bring up a menu showing the files specified
by the
<command>mailboxes</command> command, and indicate which contain new
- messages. Mutt will automatically enter this mode when invoked from the
+ messages. NeoMutt will automatically enter this mode when invoked from the
command line with the
<literal>-y</literal> option.</para>
- <para>For the pager, index and directory browser menus, Mutt contains
+ <para>For the pager, index and directory browser menus, NeoMutt contains
the
<literal><buffy-list></literal>function (bound to
<quote>.</quote>by default) which will print a list of folders with new
mail in the command line at the bottom of the screen.</para>
- <para>For the index, by default Mutt displays the number of mailboxes
+ <para>For the index, by default NeoMutt displays the number of mailboxes
with new mail in the status bar, please refer to the
<link linkend="status-format">$status_format</link> variable for
details.</para>
- <para>When changing folders, Mutt fills the prompt with the first
+ <para>When changing folders, NeoMutt fills the prompt with the first
folder from the mailboxes list containing new mail (if any), pressing
<literal><Space></literal>will cycle through folders with new
mail. The (by default unbound) function
<sect2 id="calc-mailbox-counts">
<title>Calculating Mailbox Message Counts</title>
<para>If
- <link linkend="mail-check-stats">$mail_check_stats</link> is set, Mutt
+ <link linkend="mail-check-stats">$mail_check_stats</link> is set, NeoMutt
will periodically calculate the unread, flagged, and total message
counts for each mailbox watched by the
<command>mailboxes</command> command. This calculation takes place at
<sect1 id="editing-threads">
<title>Editing Threads</title>
- <para>Mutt has the ability to dynamically restructure threads that are
+ <para>NeoMutt has the ability to dynamically restructure threads that are
broken either by misconfigured software or bad behavior from some
correspondents. This allows to clean your mailboxes from these annoyances
which make it hard to follow a discussion.</para>
<quote>forget</quote> to correctly set the
<quote>In-Reply-To:</quote>and
<quote>References:</quote>headers when replying to a message. This
- results in broken discussions because Mutt has not enough information
+ results in broken discussions because NeoMutt has not enough information
to guess the correct threading. You can fix this by tagging the reply,
then moving to the parent message and using the
<literal><link-threads></literal>function (bound to & by
whether DSN is supported.</para>
<para>For SMTP delivery using
<link linkend="smtp-url">$smtp_url</link>, it depends on the capabilities
- announced by the server whether Mutt will attempt to request DSN or
+ announced by the server whether NeoMutt will attempt to request DSN or
not.</para>
</sect1>
<varlistentry>
<term>Address normalization</term>
<listitem>
- <para>Mutt normalizes all e-mail addresses to the simplest form
+ <para>NeoMutt normalizes all e-mail addresses to the simplest form
possible. If an address contains a realname, the form
<emphasis>Joe User <joe@example.com></emphasis>is used and
the pure e-mail address without angle brackets otherwise, i.e. just
<emphasis>joe@example.com</emphasis>.</para>
- <para>This normalization affects all headers Mutt generates
+ <para>This normalization affects all headers NeoMutt generates
including aliases.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Initial folder selection</term>
<listitem>
- <para>The folder Mutt opens at startup is determined as follows:
+ <para>The folder NeoMutt opens at startup is determined as follows:
the folder specified in the
<literal>$MAIL</literal> environment variable if present. Otherwise,
the value of
<literal>$MAILDIR</literal> is taken into account. If that isn't
- present either, Mutt takes the user's mailbox in the mailspool as
+ present either, NeoMutt takes the user's mailbox in the mailspool as
determined at compile-time (which may also reside in the home
directory). The
<link linkend="spoolfile">$spoolfile</link> setting overrides this
</chapter>
<chapter id="mimesupport">
- <title>Mutt's MIME Support</title>
- <para>Quite a bit of effort has been made to make Mutt the premier
+ <title>NeoMutt's MIME Support</title>
+ <para>Quite a bit of effort has been made to make NeoMutt the premier
text-mode MIME MUA. Every effort has been made to provide the functionality
that the discerning MIME user requires, and the conformance to the
- standards wherever possible. When configuring Mutt for MIME, there are two
- extra types of configuration files which Mutt uses. One is the
+ standards wherever possible. When configuring NeoMutt for MIME, there are two
+ extra types of configuration files which NeoMutt uses. One is the
<literal>mime.types</literal> file, which contains the mapping of file
extensions to IANA MIME types. The other is the
<literal>mailcap</literal> file, which specifies the external commands to
use for handling specific MIME types.</para>
<sect1 id="using-mime">
- <title>Using MIME in Mutt</title>
+ <title>Using MIME in NeoMutt</title>
<sect2 id="mime-overview">
<title>MIME Overview</title>
thus form a tree structure), nearly arbitrary characters can be used
for sender names, recipients and subjects.</para>
<para>Besides the handling of non-ascii characters in message headers,
- to Mutt the most important aspect of MIME are so-called MIME types.
+ to NeoMutt the most important aspect of MIME are so-called MIME types.
These are constructed using a
<emphasis>major</emphasis> and
<emphasis>minor</emphasis> type separated by a forward slash. These
- specify details about the content that follows. Based upon these, Mutt
+ specify details about the content that follows. Based upon these, NeoMutt
decides how to handle this part. The most popular major type is
<quote>
<literal>text</literal>
<literal>quoted-printable</literal>,
<literal>base64</literal> and
<literal>binary</literal>. There're some rules when to choose what for
- encoding headers and/or body (if needed), and Mutt will in general make
+ encoding headers and/or body (if needed), and NeoMutt will in general make
a good choice.</para>
- <para>Mutt does most of MIME encoding/decoding behind the scenes to
+ <para>NeoMutt does most of MIME encoding/decoding behind the scenes to
form messages conforming to MIME on the sending side. On reception, it
can be flexibly configured as to how what MIME structure is displayed
(and if it's displayed): these decisions are based on the content's
<sect2 id="mime-pager">
<title>Viewing MIME Messages in the Pager</title>
<para>When you select a message from the index and view it in the
- pager, Mutt decodes as much of a message as possible to a text
- representation. Mutt internally supports a number of MIME types,
+ pager, NeoMutt decodes as much of a message as possible to a text
+ representation. NeoMutt internally supports a number of MIME types,
including the
<literal>text</literal> major type (with all minor types), the
<literal>message/rfc822</literal>(mail messages) type and some
<literal>multipart</literal> types. In addition, it recognizes a variety
of PGP MIME types, including PGP/MIME and
<literal>application/pgp</literal>.</para>
- <para>Mutt will denote attachments with a couple lines describing them.
+ <para>NeoMutt will denote attachments with a couple lines describing them.
These lines are of the form:</para>
<screen>
[-- Attachment #1: Description --]
for the attachment, and the
<emphasis>Encoding</emphasis> is one of the already mentioned content
encodings.</para>
- <para>If Mutt cannot deal with a MIME type, it will display a message
+ <para>If NeoMutt cannot deal with a MIME type, it will display a message
like:</para>
<screen>[-- image/gif is unsupported (use 'v' to view this part) --]</screen>
</sect2>
information, notably the type, encoding and description.</para>
<para>Attachments appear as follows by default:</para>
<screen>
-- 1 [text/plain, 7bit, 1K] /tmp/mutt-euler-8082-0 <no description>
- 2 [applica/x-gunzip, base64, 422K] ~/src/mutt-0.85.tar.gz <no description>
+- 1 [text/plain, 7bit, 1K] /tmp/neomutt-euler-8082-0 <no description>
+ 2 [applica/x-gunzip, base64, 422K] ~/src/neomutt-0.85.tar.gz <no description>
</screen>
<para>The
- <quote>-</quote>denotes that Mutt will delete the file after sending
+ <quote>-</quote>denotes that NeoMutt will delete the file after sending
(or postponing, or canceling) the message. It can be toggled with the
<literal><toggle-unlink></literal>command (default: u). The next
field is the MIME content-type, and can be changed with the
<para>To get most out of MIME, it's important that a MIME part's content
type matches the content as closely as possible so that the recipient's
client can automatically select the right viewer for the content.
- However, there's no reliable for Mutt to know how to detect every
+ However, there's no reliable for NeoMutt to know how to detect every
possible file type. Instead, it uses a simple plain text mapping file
that specifies what file extension corresponds to what MIME type. This
file is called
<literal>mime.types</literal>.</para>
- <para>When you add an attachment to your mail message, Mutt searches your
+ <para>When you add an attachment to your mail message, NeoMutt searches your
personal
<literal>mime.types</literal> file at
<literal>$HOME/.mime.types</literal>, and then the system
<literal>mime.types</literal> file at
- <literal>/usr/local/share/mutt/mime.types</literal> or
+ <literal>/usr/local/share/neomutt/mime.types</literal> or
<literal>/etc/mime.types</literal></para>
<para>Each line starts with the full MIME type, followed by a space and
space-separated list of file extensions. For example you could
</screen>
</example>
<para>A sample
- <literal>mime.types</literal> file comes with the Mutt distribution, and
+ <literal>mime.types</literal> file comes with the NeoMutt distribution, and
should contain most of the MIME types you are likely to use.</para>
- <para>If Mutt can not determine the MIME type by the extension of the
+ <para>If NeoMutt can not determine the MIME type by the extension of the
file you attach, it will run the command specified in
<link linkend="mime-type-query-command">$mime_type_query_command</link>.
- If that command is not specified, Mutt will look at the file. If the file
- is free of binary information, Mutt will assume that the file is plain
+ If that command is not specified, NeoMutt will look at the file. If the file
+ is free of binary information, NeoMutt will assume that the file is plain
text, and mark it as
<literal>text/plain</literal>. If the file contains binary information,
- then Mutt will mark it as
+ then NeoMutt will mark it as
<literal>application/octet-stream</literal>. You can change the MIME type
- that Mutt assigns to an attachment by using the
+ that NeoMutt assigns to an attachment by using the
<literal><edit-type></literal>command from the compose menu
(default: ^T), see
- <xref linkend="supported-mime-types" />for supported major types. Mutt
+ <xref linkend="supported-mime-types" />for supported major types. NeoMutt
recognizes all of these if the appropriate entry is found in the
<literal>mime.types</literal> file. Non-recognized mime types should only
be used if the recipient of the message is likely to be expecting such
<sect1 id="mailcap">
<title>MIME Viewer Configuration with Mailcap</title>
- <para>Mutt supports RFC 1524 MIME Configuration, in particular the Unix
+ <para>NeoMutt supports RFC 1524 MIME Configuration, in particular the Unix
specific format specified in Appendix A of RFC 1524. This file format is
commonly referred to as the
<quote>mailcap</quote> format. Many MIME compliant programs utilize the
mailcap format, allowing you to specify handling for all MIME types in
one place for all programs. Programs known to use this format include
Firefox, lynx and metamail.</para>
- <para>In order to handle various MIME types that Mutt doesn't have
+ <para>In order to handle various MIME types that NeoMutt doesn't have
built-in support for, it parses a series of external configuration files
to find an external handler. The default search string for these files is
a colon delimited list containing the following files:</para>
<para>where
<literal>$HOME</literal> is your home directory. The
<literal>$PKGDATADIR</literal> and the
- <literal>$SYSCONFDIR</literal> directories depend on where Mutt is
+ <literal>$SYSCONFDIR</literal> directories depend on where NeoMutt is
installed: the former is the default for shared data, the latter for
system configuration files.</para>
<para>The default search path can be obtained by running the following
command:</para>
- <screen>mutt -nF /dev/null -Q mailcap_path</screen>
+ <screen>neomutt -nF /dev/null -Q mailcap_path</screen>
<para>In particular, the metamail distribution will install a mailcap
file, usually as
<literal>/usr/local/etc/mailcap</literal>, which contains some baseline
default is to send the body of the MIME message to the command on
stdin. You can change this behavior by using
<literal>%s</literal> as a parameter to your view command. This will
- cause Mutt to save the body of the MIME message to a temporary file,
+ cause NeoMutt to save the body of the MIME message to a temporary file,
and then call the view command with the
<literal>%s</literal> replaced by the name of the temporary file. In
- both cases, Mutt will turn over the terminal to the view program until
- the program quits, at which time Mutt will remove the temporary file if
+ both cases, NeoMutt will turn over the terminal to the view program until
+ the program quits, at which time NeoMutt will remove the temporary file if
it exists. This means that mailcap does
<emphasis>not</emphasis> work out of the box with programs which detach
themselves from the terminal right after starting, like
<sect2 id="secure-mailcap">
<title>Secure Use of Mailcap</title>
<para>The interpretation of shell meta-characters embedded in MIME
- parameters can lead to security problems in general. Mutt tries to
+ parameters can lead to security problems in general. NeoMutt tries to
quote parameters in expansion of
<literal>%s</literal> syntaxes properly, and avoids risky characters by
substituting them, see the
<link linkend="mailcap-sanitize">
$mailcap_sanitize</link> variable.</para>
- <para>Although Mutt's procedures to invoke programs with mailcap seem
+ <para>Although NeoMutt's procedures to invoke programs with mailcap seem
to be safe, there are other applications parsing mailcap, maybe taking
less care of it. Therefore you should pay attention to the following
rules:</para>
<para>
<emphasis>Keep the %-expandos away from shell quoting.</emphasis>Don't
- quote them with single or double quotes. Mutt does this for you, the
+ quote them with single or double quotes. NeoMutt does this for you, the
right way, as should any other program which interprets mailcap. Don't
put them into backtick expansions. Be highly careful with evil
statements, and avoid them if possible at all. Trying to fix broken
<title>Optional Fields</title>
<para>In addition to the required content-type and view command
fields, you can add semi-colon
- <quote>;</quote>separated fields to set flags and other options. Mutt
+ <quote>;</quote>separated fields to set flags and other options. NeoMutt
recognizes the following optional fields:</para>
<variablelist>
<varlistentry>
<term>copiousoutput</term>
<listitem>
- <para>This flag tells Mutt that the command passes possibly
- large amounts of text on standard output. This causes Mutt to
+ <para>This flag tells NeoMutt that the command passes possibly
+ large amounts of text on standard output. This causes NeoMutt to
invoke a pager (either the internal pager or the external pager
defined by the pager variable) on the output of the view
- command. Without this flag, Mutt assumes that the command is
+ command. Without this flag, NeoMutt assumes that the command is
interactive. One could use this to replace the pipe to
<literal>more</literal> in the
<literal>lynx -dump</literal> example in the Basic
<screen>text/html; lynx -dump %s ; copiousoutput</screen>
<para>This will cause lynx to format the
<literal>text/html</literal> output as
- <literal>text/plain</literal> and Mutt will use your standard
+ <literal>text/plain</literal> and NeoMutt will use your standard
pager to display the results.</para>
- <para>Mutt will set the
+ <para>NeoMutt will set the
<literal>COLUMNS</literal> environment variable to the width of
the pager. Some programs make use of this environment variable
automatically. Others provide a command line argument that can
<varlistentry>
<term>needsterminal</term>
<listitem>
- <para>Mutt uses this flag when viewing attachments with
+ <para>NeoMutt uses this flag when viewing attachments with
<link linkend="auto-view">
<command>auto_view</command>
</link>, in order to decide whether it should honor the setting
<link linkend="wait-key">$wait_key</link> variable or not. When
an attachment is viewed using an interactive program, and the
corresponding mailcap entry has a
- <emphasis>needsterminal</emphasis> flag, Mutt will use
+ <emphasis>needsterminal</emphasis> flag, NeoMutt will use
<link linkend="wait-key">$wait_key</link> and the exit status of
the program to decide if it will ask you to press a key after
the external program has exited. In all other situations it
<term>compose=<command></term>
<listitem>
<para>This flag specifies the command to use to create a new
- attachment of a specific MIME type. Mutt supports this from the
+ attachment of a specific MIME type. NeoMutt supports this from the
compose menu.</para>
</listitem>
</varlistentry>
<listitem>
<para>This flag specifies the command to use to create a new
attachment of a specific MIME type. This command differs from
- the compose command in that Mutt will expect standard MIME
+ the compose command in that NeoMutt will expect standard MIME
headers on the data. This can be used to specify parameters,
- filename, description, etc. for a new attachment. Mutt supports
+ filename, description, etc. for a new attachment. NeoMutt supports
this from the compose menu.</para>
</listitem>
</varlistentry>
<term>print=<command></term>
<listitem>
<para>This flag specifies the command to use to print a
- specific MIME type. Mutt supports this from the attachment and
+ specific MIME type. NeoMutt supports this from the attachment and
compose menus.</para>
</listitem>
</varlistentry>
<term>edit=<command></term>
<listitem>
<para>This flag specifies the command to use to edit a specific
- MIME type. Mutt supports this from the compose menu, and also
- uses it to compose new attachments. Mutt will default to the
+ MIME type. NeoMutt supports this from the compose menu, and also
+ uses it to compose new attachments. NeoMutt will default to the
defined
<link linkend="editor">$editor</link> for text
attachments.</para>
<para>This field specifies a command to run to test whether
this mailcap entry should be used. The command is defined with
the command expansion rules defined in the next section. If the
- command returns 0, then the test passed, and Mutt uses this
+ command returns 0, then the test passed, and NeoMutt uses this
entry. If the command returns non-zero, then the test failed,
- and Mutt continues searching for the right entry. Note that the
- content-type must match before Mutt performs the test. For
+ and NeoMutt continues searching for the right entry. Note that the
+ content-type must match before NeoMutt performs the test. For
example:</para>
<screen>
text/html; firefox -remote 'openURL(%s)' ; test=RunningX
text/html; lynx %s
</screen>
- <para>In this example, Mutt will run the program
+ <para>In this example, NeoMutt will run the program
<literal>RunningX</literal> which will return 0 if the X Window
manager is running, and non-zero if it isn't. If
- <literal>RunningX</literal> returns 0, then Mutt will run
+ <literal>RunningX</literal> returns 0, then NeoMutt will run
firefox to display the
<literal>text/html</literal> object. If RunningX doesn't return
- 0, then Mutt will go on to the next entry and use lynx to
+ 0, then NeoMutt will go on to the next entry and use lynx to
display the
<literal>text/html</literal> object.</para>
</listitem>
<sect3 id="mailcap-search-order">
<title>Search Order</title>
- <para>When searching for an entry in the mailcap file, Mutt will
+ <para>When searching for an entry in the mailcap file, NeoMutt will
search for the most useful entry for its purpose. For instance, if
you are attempting to print an
<literal>image/gif</literal>, and you have the following entries in
- your mailcap file, Mutt will search for an entry with the print
+ your mailcap file, NeoMutt will search for an entry with the print
command:</para>
<screen>
image/*; xv %s
image/gif; ; print= anytopnm %s | pnmtops | lpr; \
nametemplate=%s.gif
</screen>
- <para>Mutt will skip the
+ <para>NeoMutt will skip the
<literal>image/*</literal>entry and use the
<literal>image/gif</literal> entry with the print command.</para>
<para>In addition, you can use this with
<para>For
<link linkend="auto-view">
<command>auto_view</command>
- </link>, Mutt will choose the third entry because of the
- <literal>copiousoutput</literal> tag. For interactive viewing, Mutt
+ </link>, NeoMutt will choose the third entry because of the
+ <literal>copiousoutput</literal> tag. For interactive viewing, NeoMutt
will run the program
<literal>RunningX</literal> to determine if it should use the first
- entry. If the program returns non-zero, Mutt will use the second
+ entry. If the program returns non-zero, NeoMutt will use the second
entry for interactive viewing. The last entry is for inline display
in the pager and the
<literal><view-attach></literal>function in the attachment
actually be the first matching one with the tag set. For
non-interactive use, only
<literal>copiousoutput</literal>-tagged entries are considered. For
- interactive use, Mutt ignores this tag and treats all entries
+ interactive use, NeoMutt ignores this tag and treats all entries
equally. Therefore, if not specified last, all following entries
without this tag would never be considered for
<literal><view-attach></literal>because the
<literal>/bin/sh</literal> shell using the
<literal>system(3)</literal>function. Before the command is passed to
<literal>/bin/sh -c</literal>, it is parsed to expand various special
- parameters with information from Mutt. The keywords Mutt expands
+ parameters with information from NeoMutt. The keywords NeoMutt expands
are:</para>
<variablelist>
<varlistentry>
expanded to a filename specified by the calling program. This
file contains the body of the message to view/print/edit or
where the composing program should place the results of
- composition. In addition, the use of this keyword causes Mutt
+ composition. In addition, the use of this keyword causes NeoMutt
to not pass the body of the message to the view/print/edit
program on stdin.</para>
</listitem>
<varlistentry>
<term>%t</term>
<listitem>
- <para>Mutt will expand
+ <para>NeoMutt will expand
<literal>%t</literal> to the text representation of the content
type of the message in the same form as the first parameter of
the mailcap definition line, i.e.
<varlistentry>
<term>%{<parameter>}</term>
<listitem>
- <para>Mutt will expand this to the value of the specified
+ <para>NeoMutt will expand this to the value of the specified
parameter from the Content-Type: line of the mail message. For
instance, if your mail message contains:</para>
<screen>Content-Type: text/plain; charset=iso-8859-1</screen>
- <para>then Mutt will expand
+ <para>then NeoMutt will expand
<literal>%{charset}</literal>to
<quote>iso-8859-1</quote>. The default metamail mailcap file
uses this feature to test the charset to spawn an xterm using
</listitem>
</varlistentry>
</variablelist>
- <para>Mutt does not currently support the
+ <para>NeoMutt does not currently support the
<literal>%F</literal> and
<literal>%n</literal> keywords specified in RFC 1524. The main purpose
of these parameters is for multipart messages, which is handled
- internally by Mutt.</para>
+ internally by NeoMutt.</para>
</sect3>
</sect2>
</arg>
</group>
</cmdsynopsis>
- <para>In addition to explicitly telling Mutt to view an attachment with
+ <para>In addition to explicitly telling NeoMutt to view an attachment with
the MIME viewer defined in the mailcap file from the attachments menu,
- Mutt has support for automatically viewing MIME attachments while in the
+ NeoMutt has support for automatically viewing MIME attachments while in the
pager.</para>
<para>For this to work, you must define a viewer in the mailcap file
which uses the
auto_view text/html application/x-gunzip \
application/postscript image/gif application/x-tar-gz
</screen>
- <para>...Mutt would try to find corresponding entries for rendering
+ <para>...NeoMutt would try to find corresponding entries for rendering
attachments of these types as text. A corresponding mailcap could look
like:</para>
<screen>
MIME parts which represent the same content in an alternative way. This
is often used to send HTML messages which contain an alternative plain
text representation.</para>
- <para>Mutt has some heuristics for determining which attachment of a
+ <para>NeoMutt has some heuristics for determining which attachment of a
<literal>multipart/alternative</literal> type to display:</para>
<orderedlist>
<listitem>
- <para>First, Mutt will check the
+ <para>First, NeoMutt will check the
<command>alternative_order</command> list to determine if one of the
available types is preferred. It consists of a number of MIME types
in order, including support for implicit and explicit wildcards. For
</screen>
</listitem>
<listitem>
- <para>Next, Mutt will check if any of the types have a defined
+ <para>Next, NeoMutt will check if any of the types have a defined
<link linkend="auto-view">
<command>auto_view</command>
</link>, and use that.</para>
</listitem>
<listitem>
- <para>Failing that, Mutt will look for any text type.</para>
+ <para>Failing that, NeoMutt will look for any text type.</para>
</listitem>
<listitem>
- <para>As a last attempt, Mutt will look for any type it knows how to
+ <para>As a last attempt, NeoMutt will look for any type it knows how to
handle.</para>
</listitem>
</orderedlist>
<sect1 id="attachments">
<title>Attachment Searching and Counting</title>
- <para>If you ever lose track of attachments in your mailboxes, Mutt's
+ <para>If you ever lose track of attachments in your mailboxes, NeoMutt's
attachment-counting and -searching support might be for you. You can make
your message index display the number of qualifying attachments in each
message, or search for messages by attachment count. You also can
configure what kinds of attachments qualify for this feature with the
<command>attachments</command> and
<command>unattachments</command> commands.</para>
- <para>In order to provide this information, Mutt needs to fully
+ <para>In order to provide this information, NeoMutt needs to fully
MIME-parse all messages affected first. This can slow down operation
especially for remote mail folders such as IMAP because all messages have
to be downloaded first regardless whether the user really wants to view
# Qualify any MIME part with an "attachment" disposition, EXCEPT for
# text/x-vcard and application/pgp parts. (PGP parts are already known
-# to mutt, and can be searched for with ~g, ~G, and ~k.)
+# to NeoMutt, and can be searched for with ~g, ~G, and ~k.)
#
# I've added x-pkcs7 to this, since it functions (for S/MIME)
# analogously to PGP signature attachments. S/MIME isn't supported
-# in a stock mutt build, but we can still treat it specially here.
+# in a stock NeoMutt build, but we can still treat it specially here.
#
</emphasis>
</emphasis>
attachments +I text/plain
<emphasis role="comment">
-# These two lines make Mutt qualify MIME containers. (So, for example,
+# These two lines make NeoMutt qualify MIME containers. (So, for example,
# a message/rfc822 forward will count as an attachment.) The first
# line is unnecessary if you already have "attach-allow */.*", of
# course. These are off by default! The MIME elements contained
</arg>
</group>
</cmdsynopsis>
- <para>Mutt's
+ <para>NeoMutt's
<command>mime_lookup</command> list specifies a list of MIME types that
should
<emphasis>not</emphasis> be treated according to their mailcap entry. This
<sect2 id="compile-time-features">
<title>Enabling/Disabling Features</title>
- <para>Mutt supports several of optional features which can be enabled
+ <para>NeoMutt supports several of optional features which can be enabled
or disabled at compile-time by giving the
<emphasis>configure</emphasis> script certain arguments. These are
listed in the
<emphasis>configure --help</emphasis> output.</para>
<para>Which features are enabled or disabled can later be determined
from the output of
- <literal>mutt -v</literal>. If a compile option starts with
+ <literal>neomutt -v</literal>. If a compile option starts with
<quote>+</quote>it is enabled and disabled if prefixed with
- <quote>-</quote>. For example, if Mutt was compiled using GnuTLS for
+ <quote>-</quote>. For example, if NeoMutt was compiled using GnuTLS for
encrypted communication instead of OpenSSL,
- <literal>mutt -v</literal> would contain:</para>
+ <literal>neomutt -v</literal> would contain:</para>
<screen>-openssl +gnutls</screen>
</sect2>
<sect2 id="url-syntax">
<title>URL Syntax</title>
- <para>Mutt optionally supports the IMAP, POP3 and SMTP protocols which
+ <para>NeoMutt optionally supports the IMAP, POP3 and SMTP protocols which
require to access servers using URLs. The canonical syntax for
- specifying URLs in Mutt is (an item enclosed in
+ specifying URLs in NeoMutt is (an item enclosed in
<literal>[]</literal>means it is optional and may be omitted):</para>
<screen>proto[s]://[username[:password]@]server[:port][/path]</screen>
<para>
<literal>pop</literal> for POP3 and
<literal>smtp</literal> for SMTP. If
<quote>s</quote> for
- <quote>secure communication</quote> is appended, Mutt will attempt to
+ <quote>secure communication</quote> is appended, NeoMutt will attempt to
establish an encrypted communication using SSL or TLS.</para>
- <para>Since all protocols supported by Mutt support/require
+ <para>Since all protocols supported by NeoMutt support/require
authentication, login credentials may be specified in the URL. This has
the advantage that multiple IMAP, POP3 or SMTP servers may be specified
(which isn't possible using, for example,
<literal>%</literal>-notation.</para>
<para>A password can be given, too but is not recommended if the URL is
specified in a configuration file on disk.</para>
- <para>If no port number is given, Mutt will use the system's default
+ <para>If no port number is given, NeoMutt will use the system's default
for the given protocol (usually consulting
<literal>/etc/services</literal>).</para>
<para>The optional path is only relevant for IMAP and ignored
<sect1 id="ssl">
<title>SSL/TLS Support</title>
- <para>If Mutt is compiled with IMAP, POP3 and/or SMTP support, it can
+ <para>If NeoMutt is compiled with IMAP, POP3 and/or SMTP support, it can
also be compiled with support for SSL or TLS using either OpenSSL or
GnuTLS ( by running the
<emphasis>configure</emphasis> script with the
<emphasis>--enable-ssl=...</emphasis>option for OpenSSL or
- <emphasis>--enable-gnutls=...</emphasis>for GnuTLS). Mutt can then
+ <emphasis>--enable-gnutls=...</emphasis>for GnuTLS). NeoMutt can then
attempt to encrypt communication with remote servers if these protocols
are suffixed with
<quote>s</quote> for
<sect1 id="pop">
<title>POP3 Support</title>
- <para>Mutt has POP3 support and has the ability to work with mailboxes
+ <para>NeoMutt has POP3 support and has the ability to work with mailboxes
located on a remote POP3 server and fetch mail for local
browsing.</para>
<para>Remote POP3 servers can be accessed using URLs with the
<literal>pops</literal> for encrypted communication, see
<xref linkend="url-syntax" />for details.</para>
<para>Polling for new mail is more expensive over POP3 than locally. For
- this reason the frequency at which Mutt will check for mail remotely can
+ this reason the frequency at which NeoMutt will check for mail remotely can
be controlled by the
<link linkend="pop-checkinterval">$pop_checkinterval</link> variable,
which defaults to every 60 seconds.</para>
<para>POP is read-only which doesn't allow for some features like editing
messages or changing flags. However, using
<xref linkend="header-caching" />and
- <xref linkend="body-caching" />Mutt simulates the new/old/read flags as
- well as flagged and replied. Mutt applies some logic on top of remote
+ <xref linkend="body-caching" />NeoMutt simulates the new/old/read flags as
+ well as flagged and replied. NeoMutt applies some logic on top of remote
messages but cannot change them so that modifications of flags are lost
- when messages are downloaded from the POP server (either by Mutt or other
+ when messages are downloaded from the POP server (either by NeoMutt or other
tools).</para>
<anchor id="fetch-mail" />
<para>Another way to access your POP3 mail is the
connect to
<link linkend="pop-host">$pop_host</link>, fetch all your new mail and
place it in the local
- <link linkend="spoolfile">$spoolfile</link>. After this point, Mutt runs
+ <link linkend="spoolfile">$spoolfile</link>. After this point, NeoMutt runs
exactly as if the mail had always been local.</para>
<note>
<para>If you only need to fetch all messages to a local mailbox you
<sect1 id="imap">
<title>IMAP Support</title>
- <para>Mutt has IMAP support and has the ability to work with folders
+ <para>NeoMutt has IMAP support and has the ability to work with folders
located on a remote IMAP server.</para>
<para>You can access the remote inbox by selecting the folder by its URL
(see
<literal>
{[username@]imapserver[:port][/ssl]}path/to/folder</literal></para>
<para>Note that not all servers use
- <quote>/</quote>as the hierarchy separator. Mutt should correctly notice
+ <quote>/</quote>as the hierarchy separator. NeoMutt should correctly notice
which separator is being used by the server and convert paths
accordingly.</para>
<para>When browsing folders on an IMAP server, you can toggle whether to
<sect2 id="imap-browser">
<title>The IMAP Folder Browser</title>
- <para>As of version 1.2, Mutt supports browsing mailboxes on an IMAP
+ <para>As of version 1.2, NeoMutt supports browsing mailboxes on an IMAP
server. This is mostly the same as the local file browser, with the
following differences:</para>
<itemizedlist>
<listitem>
- <para>In lieu of file permissions, Mutt displays the string
+ <para>In lieu of file permissions, NeoMutt displays the string
<quote>IMAP</quote>, possibly followed by the symbol
<quote>+</quote>, indicating that the entry contains both messages
and subfolders. On Cyrus-like servers folders will often contain
<sect2 id="imap-authentication">
<title>Authentication</title>
- <para>Mutt supports four authentication methods with IMAP servers:
+ <para>NeoMutt supports four authentication methods with IMAP servers:
SASL, GSSAPI, CRAM-MD5, and LOGIN. There is also support for
the pseudo-protocol ANONYMOUS, which allows you to log in to a public
IMAP server without having an account. To use ANONYMOUS, simply make
GSSAPI), your entire session will be encrypted and invisible to those
teeming network snoops. It is the best option if you have it. To use
it, you must have the Cyrus SASL library installed on your system and
- compile Mutt with the
+ compile NeoMutt with the
<emphasis>--with-sasl</emphasis> flag.</para>
- <para>Mutt will try whichever methods are compiled in and available on
+ <para>NeoMutt will try whichever methods are compiled in and available on
the server, in the following order: SASL, ANONYMOUS, GSSAPI, CRAM-MD5,
LOGIN.</para>
<para>There are a few variables which control authentication:</para>
<para>
<link linkend="imap-authenticators">$imap_authenticators</link>- a
colon-delimited list of IMAP authentication methods to try, in the
- order you wish to try them. If specified, this overrides Mutt's
+ order you wish to try them. If specified, this overrides NeoMutt's
default (attempt everything, in the order listed above).</para>
</listitem>
</itemizedlist>
<sect1 id="smtp">
<title>SMTP Support</title>
<para>Besides supporting traditional mail delivery through a
- sendmail-compatible program, Mutt supports delivery through SMTP.</para>
+ sendmail-compatible program, NeoMutt supports delivery through SMTP.</para>
<para>If the configuration variable
- <link linkend="smtp-url">$smtp_url</link> is set, Mutt will contact the
- given SMTP server to deliver messages; if it is unset, Mutt will use the
+ <link linkend="smtp-url">$smtp_url</link> is set, NeoMutt will contact the
+ given SMTP server to deliver messages; if it is unset, NeoMutt will use the
program specified by
<link linkend="sendmail">$sendmail</link>.</para>
<para>For details on the URL syntax, please see
authentication using SASL. The authentication mechanisms for SASL are
specified in
<link linkend="smtp-authenticators">$smtp_authenticators</link> defaulting
- to an empty list which makes Mutt try all available methods from
+ to an empty list which makes NeoMutt try all available methods from
most-secure to least-secure.</para>
</sect1>
</link>command may help. This hook works like
<link linkend="folder-hook">
<command>folder-hook</command>
- </link>but is invoked whenever Mutt needs to access a remote mailbox
+ </link>but is invoked whenever NeoMutt needs to access a remote mailbox
(including inside the folder browser), not just when you open the
mailbox. This includes (for example) polling for new mail, storing Fcc
messages and saving messages to a folder. As a consequence,
<xref linkend="ex-multiaccount" />the folders are defined using
<link linkend="mailboxes">
<command>mailboxes</command>
- </link>so Mutt polls them for new mail. Each
+ </link>so NeoMutt polls them for new mail. Each
<link linkend="folder-hook">
<command>folder-hook</command>
</link>triggers when one mailbox below each IMAP account is opened and
<sect1 id="caching">
<title>Local Caching</title>
- <para>Mutt contains two types of local caching:
+ <para>NeoMutt contains two types of local caching:
<emphasis>(1)</emphasis>the so-called
<quote>header caching</quote> and
<emphasis>(2)</emphasis>the so-called
<quote>body caching</quote> which are both described in this
section.</para>
<para>Header caching is optional as it depends on external libraries,
- body caching is always enabled if Mutt is compiled with POP and/or IMAP
+ body caching is always enabled if NeoMutt is compiled with POP and/or IMAP
support as these use it (body caching requires no external
library).</para>
<sect2 id="header-caching">
<title>Header Caching</title>
- <para>Mutt provides optional support for caching message headers for
+ <para>NeoMutt provides optional support for caching message headers for
the following types of folders: IMAP, POP, Maildir and MH. Header
caching greatly speeds up opening large folders because for remote
folders, headers usually only need to be downloaded once. For Maildir
<para>Both cache methods can be combined using the same directory for
storage (and for IMAP/POP even provide meaningful file names) which
simplifies manual maintenance tasks.</para>
- <para>In addition to caching message headers only, Mutt can also cache
+ <para>In addition to caching message headers only, NeoMutt can also cache
whole message bodies. This results in faster display of messages for
POP and IMAP folders because messages usually have to be downloaded
only once.</para>
<para>For configuration, the variable
<link linkend="message-cachedir">$message_cachedir</link> must point to
- a directory. There, Mutt will create a hierarchy of subdirectories
+ a directory. There, NeoMutt will create a hierarchy of subdirectories
named like the account and mailbox path the cache is for.</para>
</sect2>
<link linkend="header-cache">$header_cache</link> and
<link linkend="message-cachedir">$message_cachedir</link> can be safely
set to the same value.</para>
- <para>In a header or body cache directory, Mutt creates a directory
+ <para>In a header or body cache directory, NeoMutt creates a directory
hierarchy named like:
<literal>proto:user@hostname</literal> where
<literal>proto</literal> is either
<quote>pop</quote> or
- <quote>imap.</quote>Within there, for each folder, Mutt stores messages
+ <quote>imap.</quote>Within there, for each folder, NeoMutt stores messages
in single files and header caches in files with the
<quote>.hcache</quote> extension. All files can be removed as needed if
- the consumed disk space becomes an issue as Mutt will silently fetch
+ the consumed disk space becomes an issue as NeoMutt will silently fetch
missing items again. Pathnames are always stored in UTF-8
encoding.</para>
<para>For Maildir and MH, the header cache files are named after the
<sect2 id="maint-cache">
<title>Maintenance</title>
- <para>Mutt does not (yet) support maintenance features for header cache
+ <para>NeoMutt does not (yet) support maintenance features for header cache
database files so that files have to be removed in case they grow too
big. It depends on the database library used for header caching whether
disk space freed by removing messages is re-used.</para>
- <para>For body caches, Mutt can keep the local cache in sync with the
+ <para>For body caches, NeoMutt can keep the local cache in sync with the
remote mailbox if the
<link linkend="message-cache-clean">$message_cache_clean</link> variable
is set. Cleaning means to remove messages from the cache which are no
longer present in the mailbox which only happens when other mail
- clients or instances of Mutt using a different body cache location
- delete messages (Mutt itself removes deleted messages from the cache
+ clients or instances of NeoMutt using a different body cache location
+ delete messages (NeoMutt itself removes deleted messages from the cache
when syncing a mailbox). As cleaning can take a noticeable amount of
time, it should not be set in general but only occasionally.</para>
</sect2>
<sect1 id="sending-mixmaster">
<title>Sending Anonymous Messages via Mixmaster</title>
- <para>You may also have compiled Mutt to co-operate with Mixmaster, an
+ <para>You may also have compiled NeoMutt to co-operate with Mixmaster, an
anonymous remailer. Mixmaster permits you to send your messages
- anonymously using a chain of remailers. Mixmaster support in Mutt is for
+ anonymously using a chain of remailers. Mixmaster support in NeoMutt is for
mixmaster version 2.04 or later.</para>
<para>To use it, you'll have to obey certain restrictions. Most
important, you cannot use the
<literal>Cc</literal> and
- <literal>Bcc</literal> headers. To tell Mutt to use mixmaster, you have to
+ <literal>Bcc</literal> headers. To tell NeoMutt to use mixmaster, you have to
select a remailer chain, using the mix function on the compose
menu.</para>
<para>The chain selection screen is divided into two parts. In the
<sect2 id="compose-to-sender-functions">
<title>Functions</title>
- <para>compose-to-sender adds the following function to Mutt. By
+ <para>compose-to-sender adds the following function to NeoMutt. By
default, it is not bound to a key.</para>
<table id="table-compose-to-sender-functions">
<sect2 id="compress-intro">
<title>Introduction</title>
- <para>The Compressed Folder feature allows Mutt to read mailbox files
+ <para>The Compressed Folder feature allows NeoMutt to read mailbox files
that are compressed. But it isn't limited to compressed files. It works
well with encrypted files, too. In fact, if you can create a
- program/script to convert to and from your format, then Mutt can read
+ program/script to convert to and from your format, then NeoMutt can read
it.</para>
- <para>The feature adds three hooks to Mutt:
+ <para>The feature adds three hooks to NeoMutt:
<literal>open-hook</literal>,
<literal>close-hook</literal> and
<literal>append-hook</literal>. They define commands to: uncompress a
<sect3 id="open-hook">
<title>Read from compressed mailbox</title>
<screen>open-hook regexp shell-command</screen>
- <para>If Mutt is unable to open a file, it then looks for
+ <para>If NeoMutt is unable to open a file, it then looks for
<literal>open-hook</literal> that matches the filename.</para>
<para>If your compression program doesn't have a well-defined
extension, then you can use
<screen>open-hook '\.gz$' "gzip --stdout --decompress '%f' > '%t'"</screen>
<itemizedlist>
<listitem>
- <para>Mutt finds a file,
+ <para>NeoMutt finds a file,
<quote>example.gz</quote>, that it can't read</para>
</listitem>
<listitem>
- <para>Mutt has an
+ <para>NeoMutt has an
<literal>open-hook</literal> whose regexp matches the filename:
<literal>\.gz$</literal></para>
</listitem>
<listitem>
- <para>Mutt uses the command
+ <para>NeoMutt uses the command
<literal>gzip -cd</literal> to create a temporary file that it
<emphasis>can</emphasis> read</para>
</listitem>
<sect3 id="close-hook">
<title>Write to a compressed mailbox</title>
<screen>close-hook regexp shell-command</screen>
- <para>When Mutt has finished with a compressed mail folder, it will
+ <para>When NeoMutt has finished with a compressed mail folder, it will
look for a matching
<literal>close-hook</literal> to recompress the file. This hook is
<link linkend="table-compress-optional">optional</link>.</para>
<screen>close-hook '\.gz$' "gzip --stdout '%t' > '%f'"</screen>
<itemizedlist>
<listitem>
- <para>Mutt has finished with a folder,
+ <para>NeoMutt has finished with a folder,
<quote>example.gz</quote>, that it opened with
<literal>open-hook</literal></para>
</listitem>
<para>The folder has been modified</para>
</listitem>
<listitem>
- <para>Mutt has a
+ <para>NeoMutt has a
<literal>close-hook</literal> whose regexp matches the filename:
<literal>\.gz$</literal></para>
</listitem>
<listitem>
- <para>Mutt uses the command
+ <para>NeoMutt uses the command
<literal>gzip -c</literal> to create a new compressed
file</para>
</listitem>
<sect3 id="append-hook">
<title>Append to a compressed mailbox</title>
<screen>append-hook regexp shell-command</screen>
- <para>When Mutt wants to append an email to a compressed mail folder,
+ <para>When NeoMutt wants to append an email to a compressed mail folder,
it will look for a matching
<literal>append-hook</literal>. This hook is
<link linkend="table-compress-optional">optional</link>.</para>
<para>Using the
- <literal>append-hook</literal> will save time, but Mutt won't be able
+ <literal>append-hook</literal> will save time, but NeoMutt won't be able
to determine the type of the mail folder inside the compressed
file.</para>
- <para>Mutt will
+ <para>NeoMutt will
<emphasis>assume</emphasis> the type to be that of the
- <literal>$mbox_type</literal> variable. Mutt also uses this type for
+ <literal>$mbox_type</literal> variable. NeoMutt also uses this type for
temporary files.</para>
- <para>Mutt will only use the
+ <para>NeoMutt will only use the
<literal>append-hook</literal> for existing files. The
<literal>close-hook</literal> will be used for empty, or missing
files.</para>
<screen>append-hook '\.gz$' "gzip --stdout '%t' >> '%f'"</screen>
<itemizedlist>
<listitem>
- <para>Mutt wants to append an email to a folder,
+ <para>NeoMutt wants to append an email to a folder,
<quote>example.gz</quote>, that it opened with
<literal>open-hook</literal></para>
</listitem>
<listitem>
- <para>Mutt has an
+ <para>NeoMutt has an
<literal>append-hook</literal> whose regexp matches the
filename:
<literal>\.gz$</literal></para>
</listitem>
<listitem>
- <para>Mutt knows the mailbox type from the
+ <para>NeoMutt knows the mailbox type from the
<literal>$mbox</literal> variable</para>
</listitem>
<listitem>
- <para>Mutt uses the command
+ <para>NeoMutt uses the command
<literal>gzip -c</literal> to append to an existing compressed
file</para>
</listitem>
<sect3 id="compress-empty">
<title>Empty Files</title>
- <para>Mutt assumes that an empty file is not compressed. In this
+ <para>NeoMutt assumes that an empty file is not compressed. In this
situation, unset
<link linkend="save-empty">$save_empty</link>, so that the compressed
file will be removed if you delete all of the messages.</para>
<screen>
<emphasis role="comment"># Example NeoMutt config file for the compress feature.
-# This feature adds three hooks to Mutt which allow it to
+# This feature adds three hooks to NeoMutt which allow it to
# work with compressed, or encrypted, mailboxes.
# The hooks are of the form:
<quote>Conditional Dates</quote> feature allows you to construct
<link linkend="index-format">$index_format</link> expressions based on
the age of the email.</para>
- <para>Mutt's default
+ <para>NeoMutt's default
<literal>$index_format</literal> displays email dates in the form:
abbreviated-month day-of-month —
<quote>Jan 14</quote>.</para>
<literal>strftime(3).</literal></para>
<para>By carefully picking your formats, the dates can remain
unambiguous and compact.</para>
- <para>Mutt's conditional format strings have the form: (whitespace
+ <para>NeoMutt's conditional format strings have the form: (whitespace
introduced for clarity)</para>
<screen>%? TEST ? TRUE & FALSE ?</screen>
<para>The examples below use the test
<quote>in the last 7 days</quote>, but
<quote>
<emphasis>this</emphasis> week</quote>. This doesn't match the normal
- Mutt behavior: for example
+ NeoMutt behavior: for example
<literal>~d>1w</literal> means emails dated in the last 7
days.</para>
</sect2>
<title>Introduction</title>
<para>The
<quote>fmemopen</quote> feature speeds up some searches.</para>
- <para>This feature changes a few places where Mutt creates temporary
+ <para>This feature changes a few places where NeoMutt creates temporary
files. It replaces them with in-memory buffers. This should improve the
performance when searching the header or body using the
<link linkend="thorough-search">$thorough_search</link> option.</para>
<para>This feature depends on
<literal>open_memstream()</literal>and
<literal>fmemopen()</literal>. They are provided by glibc. Without
- them, Mutt will simply create temporary files.</para>
+ them, NeoMutt will simply create temporary files.</para>
</sect2>
<sect2 id="fmemopen-see-also">
<sect2 id="forgotten-attachment-intro">
<title>Introduction</title>
<para>The <quote>forgotten-attachment</quote> feature provides a new
- setting for Mutt that alerts the user if the message body contains a
+ setting for NeoMutt that alerts the user if the message body contains a
certain keyword but there are no attachments added. This is meant to
ensure that the user does not forget to attach a file after promising
to do so in the mail. The attachment keyword will not be scanned in
<screen>
<emphasis role="comment"># Example NeoMutt config file for the forgotten-attachment feature.
-# The 'forgotten-attachment' feature provides a new setting for Mutt that
+# The 'forgotten-attachment' feature provides a new setting for NeoMutt that
# alerts the user if the message body contains a certain regular expression but there are
# no attachments added. This is meant to ensure that the user does not forget
# to attach a file after promising to do so in the mail.
<sect1 id="global-hooks">
<title>Global Hooks</title>
- <subtitle>Define actions to run globally within Mutt</subtitle>
+ <subtitle>Define actions to run globally within NeoMutt</subtitle>
<sect2 id="global-hooks-intro">
<title>Introduction</title>
<para>These hooks are called when global events take place in
- Mutt.</para>
+ NeoMutt.</para>
<itemizedlist>
<title>Run a command...</title>
<listitem>
</listitem>
<listitem>
<para>
- <emphasis role="bold">startup-hook</emphasis>- when mutt starts up,
+ <emphasis role="bold">startup-hook</emphasis>- when NeoMutt starts up,
before opening the first mailbox</para>
</listitem>
<listitem>
<para>
- <emphasis role="bold">shutdown-hook</emphasis>- mutt shuts down,
+ <emphasis role="bold">shutdown-hook</emphasis>- NeoMutt shuts down,
before closing the last mailbox</para>
</listitem>
</itemizedlist>
<para>
<emphasis role="bold">Since:</emphasis>NeoMutt 2016-08-08</para>
<para>This feature implements a new hook that is called periodically
- when Mutt checks for new mail. This hook is called every
+ when NeoMutt checks for new mail. This hook is called every
<literal>$timeout</literal> seconds.</para>
</sect3>
<sect3 id="startup-hook-intro">
<title>Startup Hook</title>
- <subtitle>Run a command when mutt starts up, before opening the first
+ <subtitle>Run a command when NeoMutt starts up, before opening the first
mailbox</subtitle>
<para>
<emphasis role="bold">Since:</emphasis>NeoMutt 2016-11-25</para>
- <para>This feature implements a new hook that is called when Mutt
+ <para>This feature implements a new hook that is called when NeoMutt
first starts up, but before opening the first mailbox. This is most
likely to be useful to users of
<link linkend="notmuch">notmuch</link>.</para>
<sect3 id="shutdown-hook">
<title>Shutdown Hook</title>
- <subtitle>Run a command when mutt shuts down, before closing the last
+ <subtitle>Run a command when NeoMutt shuts down, before closing the last
mailbox</subtitle>
<para>
<emphasis role="bold">Since:</emphasis>NeoMutt 2016-11-25</para>
- <para>This feature implements a hook that is called when Mutt shuts
+ <para>This feature implements a hook that is called when NeoMutt shuts
down, but before closing the first mailbox. This is most likely to be
useful to users of
<link linkend="notmuch">notmuch</link>.</para>
<cmdsynopsis>
<command>timeout-hook</command>
<arg choice="plain">
- <replaceable class="parameter">MUTT-COMMAND</replaceable>
+ <replaceable class="parameter">NEOMUTT-COMMAND</replaceable>
</arg>
</cmdsynopsis>
<cmdsynopsis>
<command>startup-hook</command>
<arg choice="plain">
- <replaceable class="parameter">MUTT-COMMAND</replaceable>
+ <replaceable class="parameter">NEOMUTT-COMMAND</replaceable>
</arg>
</cmdsynopsis>
<cmdsynopsis>
<command>shutdown-hook</command>
<arg choice="plain">
- <replaceable class="parameter">MUTT-COMMAND</replaceable>
+ <replaceable class="parameter">NEOMUTT-COMMAND</replaceable>
</arg>
</cmdsynopsis>
</sect2>
# --------------------------------------------------------------------------
# COMMANDS - shown with an example argument
# --------------------------------------------------------------------------
-# After $timeout seconds of inactivity, run this mutt command</emphasis>
+# After $timeout seconds of inactivity, run this NeoMutt command</emphasis>
timeout-hook 'exec sync-mailbox'
-<emphasis role="comment"># When mutt first loads, run this mutt command</emphasis>
+<emphasis role="comment"># When NeoMutt first loads, run this NeoMutt command</emphasis>
startup-hook 'exec sync-mailbox'
-<emphasis role="comment"># When mutt quits, run this mutt command</emphasis>
+<emphasis role="comment"># When NeoMutt quits, run this NeoMutt command</emphasis>
shutdown-hook 'exec sync-mailbox'
<emphasis role="comment"># vim: syntax=muttrc</emphasis>
<sect2 id="ifdef-intro">
<title>Introduction</title>
<para>The
- <quote>ifdef</quote> feature introduces three new commands to Mutt and
- allow you to share one config file between versions of Mutt that may
+ <quote>ifdef</quote> feature introduces three new commands to NeoMutt and
+ allow you to share one config file between versions of NeoMutt that may
have different features compiled in.</para>
<screen>
ifdef symbol config-command [args...] <emphasis role="comment"># If a symbol is defined</emphasis>
<link linkend="commands">command</link> or compile-time symbol, such as
<quote>imap</quote>.</para>
<para>A list of compile-time symbols can be seen in the output of the
- command <screen>mutt -v</screen> (in the <quote>Compile options</quote>
+ command <screen>neomutt -v</screen> (in the <quote>Compile options</quote>
section).</para>
<para>
<literal>finish</literal> is particularly useful when combined with
<emphasis role="comment"># Example NeoMutt config file for the ifdef feature.
# This feature introduces three useful commands which allow you to share
-# one config file between versions of Mutt that may have different
+# one config file between versions of NeoMutt that may have different
# features compiled in.
# ifdef symbol config-command [args...]
# ifndef symbol config-command [args...]
# finish
-# The 'ifdef' command tests whether Mutt understands the name of
+# The 'ifdef' command tests whether NeoMutt understands the name of
# a variable, function, command or compile-time symbol.
# If it does, then it executes a config command.
# The 'ifndef' command tests whether a symbol does NOT exist.
-# The 'finish' command tells Mutt to stop reading current config file.
+# The 'finish' command tells NeoMutt to stop reading current config file.
# If the 'trash' variable exists, set it.</emphasis>
ifdef trash 'set trash=~/Mail/trash'
<emphasis role="comment"># If the 'tag-pattern' function exists, bind a key to it.</emphasis>
ifdef tag-pattern 'bind index <F6> tag-pattern'
<emphasis role="comment"># If the 'imap-fetch-mail' command exists, read my IMAP config.</emphasis>
-ifdef imap-fetch-mail 'source ~/.mutt/imap.rc'
+ifdef imap-fetch-mail 'source ~/.neomutt/imap.rc'
<emphasis role="comment"># If the compile-time symbol 'sidebar' does not exist, then
# stop reading the current config file.</emphasis>
ifndef sidebar finish
if needed, pick a pattern to match.</para>
<para>Note: The pattern does not have to refer to the object you wish
to color. e.g.</para>
- <screen>color index_author red default "~smutt"</screen>
+ <screen>color index_author red default "~sneomutt"</screen>
<para>The author appears red when the subject (~s) contains
- <quote>mutt</quote>.</para>
+ <quote>neomutt</quote>.</para>
</sect2>
<sect2 id="index-color-colors">
<sect2 id="keywords-intro">
<title>Introduction</title>
<para>Unify label/keyword handling.</para>
- <para>Since x-labels were added to mutt in 2000, a number of other
+ <para>Since x-labels were added to NeoMutt in 2000, a number of other
approaches to what we now call
<quote>tagging</quote> have also emerged. One of them was even made
standard in RFC 2822. This update unifies the handling of all these
strategies.</para>
- <para>We start by changing mutt's internal keyword storage from a
+ <para>We start by changing NeoMutt's internal keyword storage from a
single string which may contain whitespace to a list of discrete
keywords. This has advantages for keyword completion as well as for
portability among varying "standards" for keyword storage. This may
- represent a significant change for existing mutt users who have set
+ represent a significant change for existing NeoMutt users who have set
x-labels containing spaces, and should be regarded with suspicion. The
advantages are significant, though.</para>
- <para>Next we allow mutt to parse keywords into this internal list from
+ <para>Next we allow NeoMutt to parse keywords into this internal list from
any of the following headers: X-Label (freeform), X-Keywords
(space-delimited), X-Mozilla-Keys (space-delimited), and Keywords (RFC
- 2822, comma-space-delimited). Mutt remembers which headers it sourced
+ 2822, comma-space-delimited). NeoMutt remembers which headers it sourced
keywords from, and can rewrite those headers when saving messages for
compatibility with the mailer of origin.</para>
- <para>(X-Label was specified as freeform text by mutt, its only known
+ <para>(X-Label was specified as freeform text by NeoMutt, its only known
implementation. X-Labels have been used both as a
<quote>tagging</quote> device, probably with space delimiting, and as a
<quote>memo</quote> field, where space-delimited parsing would ruin the
- semantics of the memo. By default mutt will not split X-Labels at all.
+ semantics of the memo. By default NeoMutt will not split X-Labels at all.
Set $xlabel_delimiter if your needs vary.)</para>
<para>Finally we add two booleans: $keywords_legacy=true and
- $keywords_standard=FALSE. When $keywords_legacy is true, mutt will
+ $keywords_standard=FALSE. When $keywords_legacy is true, NeoMutt will
always save keyword to whatever original header it came from. When
- $keywords_standard=true, mutt will save to the Keywords: header. If
- both are true mutt saves to both; if neither is true, mutt saves only
+ $keywords_standard=true, NeoMutt will save to the Keywords: header. If
+ both are true NeoMutt saves to both; if neither is true, NeoMutt saves only
to legacy headers to avoid complete loss of keywords.</para>
<para>Overall this represents convergence path for all competing
labelling/tagging/keywording systems toward one that is specified by
RFC.</para>
- <para>You can change or delete the X-Label: field within Mutt using the
+ <para>You can change or delete the X-Label: field within NeoMutt using the
edit-label command. This works for tagged messages, too.</para>
</sect2>
<sect2 id="keywords-functions">
<title>Functions</title>
- <para>Keywords adds the following function to Mutt. By default, it is
+ <para>Keywords adds the following function to NeoMutt. By default, it is
not bound to a key.</para>
<table id="table-keywords-funcions">
# --------------------------------------------------------------------------
# VARIABLES - shown with their default values
# --------------------------------------------------------------------------
-# Should Mutt save the keywords to whatever keyword it came from?</emphasis>
+# Should NeoMutt save the keywords to whatever keyword it came from?</emphasis>
set keywords_legacy = yes
-<emphasis role="comment"># Should Mutt use the "Keywords:" header?</emphasis>
+<emphasis role="comment"># Should NeoMutt use the "Keywords:" header?</emphasis>
set keywords_standard = no
<emphasis role="comment"># How should the keywords be separated?</emphasis>
set xlabel_delimiter = ""
</listitem>
</varlistentry>
</variablelist>
- <para>To check if Mutt supports Kyoto Cabinet, look for
+ <para>To check if NeoMutt supports Kyoto Cabinet, look for
<itemizedlist>
<listitem>
<para>
- <quote>kyoto</quote> in the mutt version.</para>
+ <quote>kyoto</quote> in the NeoMutt version.</para>
</listitem>
<listitem>
<para>
</listitem>
<listitem>
<para>
- <quote>hcache backend: kyotocabinet</quote> in the mutt
+ <quote>hcache backend: kyotocabinet</quote> in the NeoMutt
version</para>
</listitem>
</itemizedlist></para>
<sect2 id="kyoto-cabinet-intro">
<title>Introduction</title>
<para>This feature adds support for using Kyoto Cabinet, the successor
- to Tokyo Cabinet, as a storage backend for Mutt's header cache
+ to Tokyo Cabinet, as a storage backend for NeoMutt's header cache
(hcache). It is enabled at configure time with the
<emphasis>--with-kyotocabinet=<path></emphasis>switch.</para>
</sect2>
<sect2 id="limit-current-thread-functions">
<title>Functions</title>
- <para>Limit-current-thread adds the following function to Mutt. By
+ <para>Limit-current-thread adds the following function to NeoMutt. By
default, it is not bound to a key.</para>
<table id="table-limit-current-thread-functions">
<sect2 id="lmdb-intro">
<title>Introduction</title>
<para>This feature adds support for using LMDB as a storage backend for
- Mutt's header cache (hcache). It is enabled at configure time with the
+ NeoMutt's header cache (hcache). It is enabled at configure time with the
<emphasis>--with-lmdb=<path></emphasis>switch.</para>
<note>
<para>It is not recommended to store the lmdb database on a shared
<sect2 id="nested-if-intro">
<title>Introduction</title>
- <para>Mutt's format strings can contain embedded if-then-else
+ <para>NeoMutt's format strings can contain embedded if-then-else
conditions. They are of the form:</para>
<screen>%?VAR?TRUE&FALSE?</screen>
<para>If the variable
<literal>%?S?Size: %S&Empty?</literal></para>
<para>Which can be read as:</para>
<literallayout>if (%S > 0) { print "Size: %S" } else { print "Empty" }</literallayout>
- <para>These conditions are useful, but in Mutt they cannot be nested
+ <para>These conditions are useful, but in NeoMutt they cannot be nested
within one another. This feature uses the notation
<literal>%<VAR?TRUE&FALSE></literal>and allows them to be
nested.</para>
<para>The
<literal>%<...></literal>notation was used to format the current
- local time. but that's not really very useful since mutt has no means
+ local time. but that's not really very useful since NeoMutt has no means
of refreshing the screen periodically.</para>
<para>A simple nested condition might be: (Some whitespace has been
introduced for clarity)</para>
<link linkend="status-format">$status_format</link>.</para>
<note>
<para>When the notification is sent, the folder of the new mail is no longer known.
- This is a limitation of Mutt. The `%f` expando will show the open folder.</para>
+ This is a limitation of NeoMutt. The `%f` expando will show the open folder.</para>
</note>
<para>For example in Linux you can use (most distributions already
provide notify-send):</para>
- <screen>set new_mail_command="notify-send --icon='/home/santiago/Pictures/mutt.png' 'New Email' '%n new messages, %u unread.' &"</screen>
+ <screen>set new_mail_command="notify-send --icon='/home/santiago/Pictures/neomutt.png' 'New Email' '%n new messages, %u unread.' &"</screen>
<para>And in OS X you will need to install a command line interface for
Notification Center, for example
<ulink url="https://github.com/julienXX/terminal-notifier">
# --------------------------------------------------------------------------
# VARIABLES - shown with their default values
# --------------------------------------------------------------------------
-# Set the command you want mutt to execute upon the receipt of a new email</emphasis>
+# Set the command you want NeoMutt to execute upon the receipt of a new email</emphasis>
set new_mail_command = ""
<emphasis role="comment"># Linux example:
-# set new_command="notify-send --icon='/home/santiago/Pictures/mutt.png' 'New Email in %f' '%n new messages, %u unread.' &"
+# set new_command="notify-send --icon='/home/santiago/Pictures/neomutt.png' 'New Email in %f' '%n new messages, %u unread.' &"
# OS X example:
# set new_mail_command="terminal-notifier -title '%v' -subtitle 'New Mail in %f' -message '%n new messages, %u unread.' -activate 'com.apple.Terminal'"
# --------------------------------------------------------------------------
<sect2 id="nntp-intro">
<title>Introduction</title>
<para>Reading news via NNTP</para>
- <para>Mutt can read from a news server using NNTP.</para>
+ <para>NeoMutt can read from a news server using NNTP.</para>
<para>The default news server can be obtained from the
<literal>$NNTPSERVER</literal> environment variable or from the
<literal>/etc/nntpserver</literal> file. Like in other news readers,
<literal><change-newsgroup></literal></para>
<para>The variable
<link linkend="news-cache-dir">$news_cache_dir</link> can be used to
- point to a directory. Mutt will create a hierarchy of subdirectories
+ point to a directory. NeoMutt will create a hierarchy of subdirectories
named like the account and newsgroup the cache is for. The hierarchy is
- also used to store header cache if Mutt was compiled with
+ also used to store header cache if NeoMutt was compiled with
<link linkend="header-caching">header cache</link> support.</para>
</sect2>
</entry>
<entry>string</entry>
<entry>
- <literal>~/.mutt</literal>
+ <literal>~/.neomutt</literal>
</entry>
</row>
<row>
<sect2 id="nntp-functions">
<title>Functions</title>
- <para>NNTP adds the following functions to Mutt. By default, none of
+ <para>NNTP adds the following functions to NeoMutt. By default, none of
them are bound to keys.</para>
<table id="table-nntp-functions">
set mime_subject = yes
set newsgroups_charset = utf-8
set newsrc = '~/.newsrc'
-set news_cache_dir = '~/.mutt'
+set news_cache_dir = '~/.neomutt'
set news_server = ''
set nntp_authenticators = ''
set nntp_context = 1000
<para>
<literal>tag:AAA and tag:BBB</literal>--encoding->
<literal>tag:AAA%20and%20tag:BBB</literal></para>
- <para>but mutt config file parser is smart enough to accept space in
+ <para>but NeoMutt config file parser is smart enough to accept space in
quoted strings. It means that you can use</para>
<para>
<literal>notmuch:///foo?query=tag:AAA and tag:BBB</literal>
<sect2 id="notmuch-functions">
<title>Functions</title>
- <para>Notmuch adds the following functions to Mutt. By default, none of
+ <para>Notmuch adds the following functions to NeoMutt. By default, none of
them are bound to keys.</para>
<table id="table-notmuch-functions">
# notmuch://<absolute path></emphasis>
set nm_default_uri = ""
<emphasis role="comment"># The messages tagged with these tags are excluded and not loaded
-# from notmuch DB to mutt unless specified explicitly.</emphasis>
+# from notmuch DB to NeoMutt unless specified explicitly.</emphasis>
set nm_exclude_tags = ""
<emphasis role="comment"># This variable specifies private notmuch tags which should not be printed
# on screen (index, pager).</emphasis>
<emphasis role="comment"># This variable specifies notmuch query type, supported types: 'threads' and
# 'messages'.</emphasis>
set nm_query_type = messages
-<emphasis role="comment"># Add messages stored to the mutt record (see $record in the mutt docs) also to notmuch DB. If you reply to an email then the new email inherits tags from the original email.
+<emphasis role="comment"># Add messages stored to the NeoMutt record (see $record in the NeoMutt docs) also to notmuch DB. If you reply to an email then the new email inherits tags from the original email.
</emphasis>
set nm_record = no
-<emphasis role="comment"># Tags that should be removed or added to the to the messages stored in the mutt record.
+<emphasis role="comment"># Tags that should be removed or added to the to the messages stored in the NeoMutt record.
example:
set record = "~/sent-mails"
# %*X soft-fill with character ``X'' as pad
</emphasis>
set vfolder_format = "%6n(%6N) %f"
-<emphasis role="comment"># When set, mutt will use the first virtual mailbox (see virtual-mailboxes)
+<emphasis role="comment"># When set, NeoMutt will use the first virtual mailbox (see virtual-mailboxes)
# as a spoolfile.</emphasis>
set virtual_spoolfile = no
<emphasis role="comment"># setup time window preferences
<entry>
<literal><quasi-delete></literal>
</entry>
- <entry>delete from mutt, don't touch on disk</entry>
+ <entry>delete from NeoMutt, don't touch on disk</entry>
</row>
</tbody>
</tgroup>
<sect2 id="reply-with-xorig-intro">
<title>Introduction</title>
- <para>Adds a reply_with_xorig for mutt configuration files. If enabled,
+ <para>Adds a reply_with_xorig for NeoMutt configuration files. If enabled,
allows to reply to an email using the email address in the first
X-Original-To: header of a mail as the From: header of the
answer.</para>
<sect2 id="sidebar-support">
<title>Support</title>
<para>
- <emphasis role="bold">Since:</emphasis>NeoMutt 2016-09-10, Mutt
+ <emphasis role="bold">Since:</emphasis>NeoMutt 2016-09-10, NeoMutt
1.7.0</para>
<para>
<emphasis role="bold">Dependencies:</emphasis>None</para>
<sect2 id="sidebar-functions">
<title>Functions</title>
- <para>Sidebar adds the following functions to Mutt. By default, none of
+ <para>Sidebar adds the following functions to NeoMutt. By default, none of
them are bound to keys.</para>
<table id="table-sidebar-functions">
<entry>
<literal>sidebar_indicator</literal>
</entry>
- <entry>mutt
+ <entry>neomutt
<literal>indicator</literal></entry>
<entry>The mailbox open in the Index panel</entry>
</row>
</table>
<para>If the
<literal>sidebar_indicator</literal> color isn't set, then the default
- Mutt indicator color will be used (the color used in the index
+ NeoMutt indicator color will be used (the color used in the index
panel).</para>
</sect2>
set sidebar_next_new_wrap = no
<emphasis role="comment"># Show the Sidebar on the right-hand side of the screen</emphasis>
set sidebar_on_right = no
-<emphasis role="comment"># The character to use as the divider between the Sidebar and the other Mutt
+<emphasis role="comment"># The character to use as the divider between the Sidebar and the other NeoMutt
# panels.</emphasis>
set sidebar_divider_char = '|'
<emphasis role="comment"># Enable extended buffy mode to calculate total, new, and flagged
# Note: All color operations are of the form:
# color OBJECT FOREGROUND BACKGROUND
# Color of the current, open, mailbox
-# Note: This is a general Mutt option which colors all selected items.</emphasis>
+# Note: This is a general NeoMutt option which colors all selected items.</emphasis>
color indicator cyan black
<emphasis role="comment"># Color of the highlighted, but not open, mailbox.</emphasis>
color sidebar_highlight black color8
-<emphasis role="comment"># Color of the divider separating the Sidebar from Mutt panels</emphasis>
+<emphasis role="comment"># Color of the divider separating the Sidebar from NeoMutt panels</emphasis>
color sidebar_divider color8 black
<emphasis role="comment"># Color to give mailboxes containing flagged mail</emphasis>
color sidebar_flagged red black
</group>
</group>
</cmdsynopsis>
- <para>With zero parameters, Mutt will set the default color for the
+ <para>With zero parameters, NeoMutt will set the default color for the
entire status bar.</para>
- <para>With one parameter, Mutt will only color the parts matching the
+ <para>With one parameter, NeoMutt will only color the parts matching the
regex.</para>
- <para>With two parameters, Mutt will only color the num'th sub-match of
+ <para>With two parameters, NeoMutt will only color the num'th sub-match of
the regex.</para>
</sect2>
# the status bar (also when it's used by the index).
# For the examples below, set some defaults</emphasis>
-set status_format='-%r-Mutt: %f [Msgs:%?M?%M/?%m%?n? New:%n?%?o? Old:%o?%?d? Del:%d?%?F? Flag:%F?%?t? Tag:%t?%?p? Post:%p?%?b? Inc:%b?%?l? %l?]---(%s/%S)-%>-(%P)---'
+set status_format='-%r-NeoMutt: %f [Msgs:%?M?%M/?%m%?n? New:%n?%?o? Old:%o?%?d? Del:%d?%?F? Flag:%F?%?t? Tag:%t?%?p? Post:%p?%?b? Inc:%b?%?l? %l?]---(%s/%S)-%>-(%P)---'
set index_format='%4C %Z %{%b %d} %-15.15L (%?l?%4l&%4c?) %s'
set sort=threads
set sort_aux=last-date-received
<emphasis role="comment"># The '1' refers to the first regex submatch, which is the inner
# part in ()s
# Highlight the mailbox</emphasis>
-color status brightwhite default 'Mutt: ([^ ]+)' 1
-<emphasis role="comment"># Search for 'Mutt: ' but only highlight what comes after it
+color status brightwhite default 'NeoMutt: ([^ ]+)' 1
+<emphasis role="comment"># Search for 'NeoMutt: ' but only highlight what comes after it
# vim: syntax=muttrc</emphasis>
</screen>
</sect2>
<sect2 id="trash-folder-support">
<title>Support</title>
<para>
- <emphasis role="bold">Since:</emphasis>NeoMutt 2016-09-10, Mutt
+ <emphasis role="bold">Since:</emphasis>NeoMutt 2016-09-10, NeoMutt
1.7.0</para>
<variablelist>
<varlistentry>
<sect2 id="trash-folder-intro">
<title>Introduction</title>
- <para>In Mutt, when you
+ <para>In NeoMutt, when you
<quote>delete</quote> an email it is first marked deleted. The email
isn't really gone until
<link linkend="index-map"><sync-mailbox></link>is called. This
<sect2 id="trash-folder-muttrc">
<title>Muttrc</title>
<screen>
-<emphasis role="comment"># Example Mutt config file for the 'trash' feature.
+<emphasis role="comment"># Example NeoMutt config file for the 'trash' feature.
# This feature defines a new 'trash' folder.
<chapter id="security">
<title>Security Considerations</title>
- <para>First of all, Mutt contains no security holes included by intention
- but may contain unknown security holes. As a consequence, please run Mutt
- only with as few permissions as possible. Especially, do not run Mutt as
+ <para>First of all, NeoMutt contains no security holes included by intention
+ but may contain unknown security holes. As a consequence, please run NeoMutt
+ only with as few permissions as possible. Especially, do not run NeoMutt as
the super user.</para>
- <para>When configuring Mutt, there're some points to note about secure
+ <para>When configuring NeoMutt, there're some points to note about secure
setups so please read this chapter carefully.</para>
<sect1 id="security-passwords">
<title>Passwords</title>
- <para>Although Mutt can be told the various passwords for accounts,
+ <para>Although NeoMutt can be told the various passwords for accounts,
please never store passwords in configuration files. Besides the fact
that the system's operator can always read them, you could forget to mask
it out when reporting a bug or asking for help via a mailing list. Even
<sect1 id="security-tempfiles">
<title>Temporary Files</title>
- <para>Mutt uses many temporary files for viewing messages, verifying
+ <para>NeoMutt uses many temporary files for viewing messages, verifying
digital signatures, etc. As long as being used, these files are visible
by other users and maybe even readable in case of misconfiguration. Also,
a different location for these files may be desired which can be changed
<sect2 id="security-leaks-mid">
<title>Message-Id: headers</title>
<para>Message-Id: headers contain a local part that is to be created in
- a unique fashion. In order to do so, Mutt will
+ a unique fashion. In order to do so, NeoMutt will
<quote>leak</quote> some information to the outside world when sending
messages: the generation of this header includes a step counter which
is increased (and rotated) with every message sent. In a longer running
- mutt session, others can make assumptions about your mailing habits
+ NeoMutt session, others can make assumptions about your mailing habits
depending on the number of messages sent. If this is not desired, the
header can be manually provided using
<link linkend="edit-headers">$edit_headers</link>(though not
<sect2 id="security-leaks-mailto">
<title>
<literal>mailto:</literal>-style Links</title>
- <para>As Mutt be can be set up to be the mail client to handle
+ <para>As NeoMutt be can be set up to be the mail client to handle
<literal>mailto:</literal>style links in websites, there're security
considerations, too. Arbitrary header fields can be embedded in these
links which could override existing header fields or attach arbitrary
<para>will send out the user's private gnupg keyring to
<literal>joe@host</literal> if the user doesn't follow the information
on screen carefully enough.</para>
- <para>To prevent these issues, Mutt by default only accepts the
+ <para>To prevent these issues, NeoMutt by default only accepts the
<literal>Subject</literal> and
<literal>Body</literal> headers. Allowed headers can be adjusted with
the
<sect1 id="security-external">
<title>External Applications</title>
- <para>Mutt in many places has to rely on external applications or for
+ <para>NeoMutt in many places has to rely on external applications or for
convenience supports mechanisms involving external applications.</para>
<para>One of these is the
<literal>mailcap</literal> mechanism as defined by RfC1524. Details about
a secure use of the mailcap mechanisms is given in
<xref linkend="secure-mailcap" />.</para>
- <para>Besides the mailcap mechanism, Mutt uses a number of other external
+ <para>Besides the mailcap mechanism, NeoMutt uses a number of other external
utilities for operation, for example to provide crypto support, in
backtick expansion in configuration files or format string filters. The
same security considerations apply for these as for tools involved via
<sect1 id="tuning-mailboxes">
<title>Reading and Writing Mailboxes</title>
- <para>Mutt's performance when reading mailboxes can be improved in two
+ <para>NeoMutt's performance when reading mailboxes can be improved in two
ways:</para>
<orderedlist>
<listitem>
<para>For remote folders (IMAP and POP) as well as folders using
- one-file-per message storage (Maildir and MH), Mutt's performance can
+ one-file-per message storage (Maildir and MH), NeoMutt's performance can
be greatly improved using
<link linkend="header-caching">header caching</link>. using a single
database per folder.</para>
</listitem>
<listitem>
- <para>Mutt provides the
+ <para>NeoMutt provides the
<link linkend="read-inc">$read_inc</link> and
<link linkend="write-inc">$write_inc</link> variables to specify at
which rate to update progress counters. If these values are too low,
- Mutt may spend more time on updating the progress counter than it
+ NeoMutt may spend more time on updating the progress counter than it
spends on actually reading/writing folders.</para>
<para>For example, when opening a maildir folder with a few thousand
messages, the default value for
may greatly differ in size and certain operations are much faster than
others, even per-folder settings of the increment variables may not be
desirable as they produce either too few or too much progress updates.
- Thus, Mutt allows to limit the number of progress updates per second
+ Thus, NeoMutt allows to limit the number of progress updates per second
it'll actually send to the terminal using the
<link linkend="time-inc">$time_inc</link> variable.</para>
</sect1>
<sect1 id="tuning-messages">
<title>Reading Messages from Remote Folders</title>
<para>Reading messages from remote folders such as IMAP an POP can be
- slow especially for large mailboxes since Mutt only caches a very limited
+ slow especially for large mailboxes since NeoMutt only caches a very limited
number of recently viewed messages (usually 10) per session (so that it
will be gone for the next session.)</para>
<para>To improve performance and permanently cache whole messages, please
- refer to Mutt's so-called
+ refer to NeoMutt's so-called
<link linkend="body-caching">body caching</link> for details.</para>
</sect1>
<sect1 id="tuning-search">
<title>Searching and Limiting</title>
<para>When searching mailboxes either via a search or a limit action, for
- some patterns Mutt distinguishes between regular expression and string
+ some patterns NeoMutt distinguishes between regular expression and string
searches. For regular expressions, patterns are prefixed with
<quote>~</quote>and with
<quote>=</quote>for string searches.</para>
<literal>~Luser@</literal>. This is especially true for searching message
bodies since a larger amount of input has to be searched.</para>
<para>As for regular expressions, a lower case string search pattern
- makes Mutt perform a case-insensitive search except for IMAP (because for
- IMAP Mutt performs server-side searches which don't support
+ makes NeoMutt perform a case-insensitive search except for IMAP (because for
+ IMAP NeoMutt performs server-side searches which don't support
case-insensitivity).</para>
</sect1>
</chapter>
<sect1 id="commandline">
<title>Command-Line Options</title>
<para>Running
- <literal>mutt</literal> with no arguments will make Mutt attempt to read
+ <literal>neomutt</literal> with no arguments will make NeoMutt attempt to read
your spool mailbox. However, it is possible to read other mailboxes and
to send messages from the command line as well.</para>
</row>
<row>
<entry>-d</entry>
- <entry>log debugging output to ~/.muttdebug0 if mutt was compiled
+ <entry>log debugging output to ~/.muttdebug0 if NeoMutt was compiled
with <literal>+debug</literal>; it can range from 1-5 and affects
verbosity (a value of 2 is recommended)</entry>
</row>
<row>
<entry>-D</entry>
- <entry>print the value of all Mutt variables to stdout</entry>
+ <entry>print the value of all NeoMutt variables to stdout</entry>
</row>
<row>
<entry>-D -S</entry>
</table>
<para>To read messages in a mailbox</para>
<cmdsynopsis>
- <command>mutt</command>
+ <command>neomutt</command>
<arg choice="opt">
<option>-nz</option>
</arg>
</cmdsynopsis>
<para>To compose a new message</para>
<cmdsynopsis>
- <command>mutt</command>
+ <command>neomutt</command>
<arg choice="opt">
<option>-En</option>
</arg>
</arg>
</group>
</cmdsynopsis>
- <para>Mutt also supports a
+ <para>NeoMutt also supports a
<quote>batch</quote> mode to send prepared messages. Simply redirect input
from the file you wish to send. For example,</para>
- <screen>mutt -s "data set for run #2" professor@bigschool.edu < ~/run2.dat</screen>
+ <screen>neomutt -s "data set for run #2" professor@bigschool.edu < ~/run2.dat</screen>
<para>will send a message to
<literal><professor@bigschool.edu></literal>with a subject of
<quote>data set for run #2</quote>. In the body of the message will be
<emphasis>file</emphasis> will be attached as a MIME part to the message.
To attach a single or several files, use
<quote>--</quote>to separate files and recipient addresses:</para>
- <screen>mutt -a image.png -- some@one.org</screen>
+ <screen>neomutt -a image.png -- some@one.org</screen>
<para>or</para>
- <screen>mutt -a *.png -- some@one.org</screen>
+ <screen>neomutt -a *.png -- some@one.org</screen>
<note>
<para>The
<literal>-a</literal> option must be last in the option list.</para>
</note>
- <para>In addition to accepting a list of email addresses, Mutt also
+ <para>In addition to accepting a list of email addresses, NeoMutt also
accepts a URL with the
<literal>mailto:</literal>schema as specified in RFC2368. This is useful
- when configuring a web browser to launch Mutt when clicking on mailto
+ when configuring a web browser to launch NeoMutt when clicking on mailto
links.</para>
- <screen>mutt mailto:some@one.org?subject=test&cc=other@one.org</screen>
+ <screen>neomutt mailto:some@one.org?subject=test&cc=other@one.org</screen>
</sect1>
<sect1 id="commands">
<title>Configuration Commands</title>
- <para>The following are the commands understood by Mutt:</para>
+ <para>The following are the commands understood by NeoMutt:</para>
<itemizedlist>
<listitem>
<cmdsynopsis>
** encoded in the character set specified by $$config_charset if it
** is \fIset\fP or the current character set otherwise.
** .pp
- ** \fBNote:\fP Mutt will not automatically source this file; you must
+ ** \fBNote:\fP NeoMutt will not automatically source this file; you must
** explicitly use the ``$source'' command for it to be executed in case
** this option points to a dedicated alias file.
** .pp
{ "ascii_chars", DT_BOOL, R_BOTH, OPT_ASCII_CHARS, 0 },
/*
** .pp
- ** If \fIset\fP, Mutt will use plain ASCII characters when displaying thread
+ ** If \fIset\fP, NeoMutt will use plain ASCII characters when displaying thread
** and attachment trees, instead of the default \fIACS\fP characters.
*/
{ "askbcc", DT_BOOL, R_NONE, OPT_ASKBCC, 0 },
/*
** .pp
- ** If \fIset\fP, Mutt will prompt you for blind-carbon-copy (Bcc) recipients
+ ** If \fIset\fP, NeoMutt will prompt you for blind-carbon-copy (Bcc) recipients
** before editing an outgoing message.
*/
{ "askcc", DT_BOOL, R_NONE, OPT_ASKCC, 0 },
/*
** .pp
- ** If \fIset\fP, Mutt will prompt you for carbon-copy (Cc) recipients before
+ ** If \fIset\fP, NeoMutt will prompt you for carbon-copy (Cc) recipients before
** editing the body of an outgoing message.
*/
#ifdef USE_NNTP
{ "ask_follow_up", DT_BOOL, R_NONE, OPT_ASK_FOLLOW_UP, 0 },
/*
** .pp
- ** If set, Mutt will prompt you for follow-up groups before editing
+ ** If set, NeoMutt will prompt you for follow-up groups before editing
** the body of an outgoing message.
*/
{ "ask_x_comment_to", DT_BOOL, R_NONE, OPT_ASK_X_COMMENT_TO, 0 },
/*
** .pp
- ** If set, Mutt will prompt you for x-comment-to field before editing
+ ** If set, NeoMutt will prompt you for x-comment-to field before editing
** the body of an outgoing message.
*/
#endif
/*
** .pp
** This variable is a colon-separated list of character encoding
- ** schemes for text file attachments. Mutt uses this setting to guess
+ ** schemes for text file attachments. NeoMutt uses this setting to guess
** which encoding files being attached are encoded in to convert them to
** a proper character set given in $$send_charset.
** .pp
/*
** .pp
** If this variable is \fIunset\fP, when operating (saving, printing, piping,
- ** etc) on a list of tagged attachments, Mutt will concatenate the
+ ** etc) on a list of tagged attachments, NeoMutt will concatenate the
** attachments and will operate on them as a single attachment. The
** $$attach_sep separator is added after each attachment. When \fIset\fP,
- ** Mutt will operate on the attachments one by one.
+ ** NeoMutt will operate on the attachments one by one.
*/
{ "attribution", DT_STRING, R_NONE, UL &Attribution, UL "On %d, %n wrote:" },
/*
** accepts for the locale environment variable \fC$$$LC_TIME\fP.
** .pp
** This variable is to allow the attribution date format to be
- ** customized by recipient or folder using hooks. By default, Mutt
+ ** customized by recipient or folder using hooks. By default, NeoMutt
** will use your locale environment, so there is no need to set
** this except to override that default.
*/
{ "autoedit", DT_BOOL, R_NONE, OPT_AUTOEDIT, 0 },
/*
** .pp
- ** When \fIset\fP along with $$edit_headers, Mutt will skip the initial
+ ** When \fIset\fP along with $$edit_headers, NeoMutt will skip the initial
** send-menu (prompting for subject and recipients) and allow you to
** immediately begin editing the body of your
** message. The send-menu may still be accessed once you have finished
{ "beep", DT_BOOL, R_NONE, OPT_BEEP, 1 },
/*
** .pp
- ** When this variable is \fIset\fP, mutt will beep when an error occurs.
+ ** When this variable is \fIset\fP, NeoMutt will beep when an error occurs.
*/
{ "beep_new", DT_BOOL, R_NONE, OPT_BEEP_NEW, 0 },
/*
** .pp
- ** When this variable is \fIset\fP, mutt will beep whenever it prints a message
+ ** When this variable is \fIset\fP, NeoMutt will beep whenever it prints a message
** notifying you of new mail. This is independent of the setting of the
** $$beep variable.
*/
{ "bounce_delivered", DT_BOOL, R_NONE, OPT_BOUNCE_DELIVERED, 1 },
/*
** .pp
- ** When this variable is \fIset\fP, mutt will include Delivered-To headers when
+ ** When this variable is \fIset\fP, NeoMutt will include Delivered-To headers when
** bouncing messages. Postfix users may wish to \fIunset\fP this variable.
*/
{ "braille_friendly", DT_BOOL, R_NONE, OPT_BRAILLE_FRIENDLY, 0 },
/*
** .pp
- ** When this variable is \fIset\fP, mutt will place the cursor at the beginning
+ ** When this variable is \fIset\fP, NeoMutt will place the cursor at the beginning
** of the current line in menus, even when the $$arrow_cursor variable
** is \fIunset\fP, making it easier for blind persons using Braille displays to
** follow these menus. The option is \fIunset\fP by default because many
{ "catchup_newsgroup", DT_QUAD, R_NONE, OPT_CATCHUP_NEWSGROUP, MUTT_ASKYES },
/*
** .pp
- ** If this variable is \fIset\fP, Mutt will mark all articles in newsgroup
+ ** If this variable is \fIset\fP, NeoMutt will mark all articles in newsgroup
** as read when you quit the newsgroup (catchup newsgroup).
*/
#endif
** Character set your terminal uses to display and enter textual data.
** It is also the fallback for $$send_charset.
** .pp
- ** Upon startup Mutt tries to derive this value from environment variables
+ ** Upon startup NeoMutt tries to derive this value from environment variables
** such as \fC$$$LC_CTYPE\fP or \fC$$$LANG\fP.
** .pp
- ** \fBNote:\fP It should only be set in case Mutt isn't able to determine the
+ ** \fBNote:\fP It should only be set in case NeoMutt isn't able to determine the
** character set used correctly.
*/
{ "check_mbox_size", DT_BOOL, R_NONE, OPT_CHECK_MBOX_SIZE, 0 },
/*
** .pp
- ** When this variable is \fIset\fP, mutt will use file size attribute instead of
+ ** When this variable is \fIset\fP, NeoMutt will use file size attribute instead of
** access time when checking for new mail in mbox and mmdf folders.
** .pp
** This variable is \fIunset\fP by default and should only be enabled when
** .pp
** Note that enabling this variable should happen before any ``$mailboxes''
** directives occur in configuration files regarding mbox or mmdf folders
- ** because mutt needs to determine the initial new mail status of such a
+ ** because NeoMutt needs to determine the initial new mail status of such a
** mailbox by performing a fast mailbox scan when it is defined.
** Afterwards the new mail status is tracked by file size changes.
*/
** \fBNote:\fP this option only affects \fImaildir\fP and \fIMH\fP style
** mailboxes.
** .pp
- ** When \fIset\fP, Mutt will check for new mail delivered while the
+ ** When \fIset\fP, NeoMutt will check for new mail delivered while the
** mailbox is open. Especially with MH mailboxes, this operation can
** take quite some time since it involves scanning the directory and
** checking each file to see if it has already been looked at. If
{ "collapse_unread", DT_BOOL, R_NONE, OPT_COLLAPSE_UNREAD, 1 },
/*
** .pp
- ** When \fIunset\fP, Mutt will not collapse a thread if it contains any
+ ** When \fIunset\fP, NeoMutt will not collapse a thread if it contains any
** unread messages.
*/
{ "collapse_flagged", DT_BOOL, R_NONE, OPT_COLLAPSE_FLAGGED, 1 },
/*
** .pp
- ** When \fIunset\fP, Mutt will not collapse a thread if it contains any
+ ** When \fIunset\fP, NeoMutt will not collapse a thread if it contains any
** flagged messages.
*/
{ "compose_format", DT_STRING, R_MENU, UL &ComposeFormat, UL "-- NeoMutt: Compose [Approx. msg size: %l Atts: %a]%>-" },
** .dt %a .dd total number of attachments
** .dt %h .dd local hostname
** .dt %l .dd approximate size (in bytes) of the current message
- ** .dt %v .dd Mutt version string
+ ** .dt %v .dd NeoMutt version string
** .de
** .pp
** See the text describing the $$status_format option for more
{ "config_charset", DT_STRING, R_NONE, UL &ConfigCharset, UL 0 },
/*
** .pp
- ** When defined, Mutt will recode commands in rc files from this
+ ** When defined, NeoMutt will recode commands in rc files from this
** encoding to the current character set as specified by $$charset
** and aliases written to $$alias_file from the current character set.
** .pp
{ "confirmappend", DT_BOOL, R_NONE, OPT_CONFIRMAPPEND, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will prompt for confirmation when appending messages to
+ ** When \fIset\fP, NeoMutt will prompt for confirmation when appending messages to
** an existing mailbox.
*/
{ "confirmcreate", DT_BOOL, R_NONE, OPT_CONFIRMCREATE, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will prompt for confirmation when saving messages to a
+ ** When \fIset\fP, NeoMutt will prompt for confirmation when saving messages to a
** mailbox which does not yet exist before creating it.
*/
{ "connect_timeout", DT_NUMBER, R_NONE, UL &ConnectTimeout, 30 },
/*
** .pp
- ** Causes Mutt to timeout a network connection (for IMAP, POP or SMTP) after this
+ ** Causes NeoMutt to timeout a network connection (for IMAP, POP or SMTP) after this
** many seconds if the connection is not able to be established. A negative
- ** value causes Mutt to wait indefinitely for the connection attempt to succeed.
+ ** value causes NeoMutt to wait indefinitely for the connection attempt to succeed.
*/
{ "content_type", DT_STRING, R_NONE, UL &ContentType, UL "text/plain" },
/*
{ "crypt_autoencrypt", DT_BOOL, R_NONE, OPT_CRYPT_AUTOENCRYPT, 0 },
/*
** .pp
- ** Setting this variable will cause Mutt to always attempt to PGP
+ ** Setting this variable will cause NeoMutt to always attempt to PGP
** encrypt outgoing messages. This is probably only useful in
** connection to the ``$send-hook'' command. It can be overridden
** by use of the pgp menu, when encryption is not required or
{ "crypt_autopgp", DT_BOOL, R_NONE, OPT_CRYPT_AUTOPGP, 1 },
/*
** .pp
- ** This variable controls whether or not mutt may automatically enable
+ ** This variable controls whether or not NeoMutt may automatically enable
** PGP encryption/signing for messages. See also $$crypt_autoencrypt,
** $$crypt_replyencrypt,
** $$crypt_autosign, $$crypt_replysign and $$smime_is_default.
{ "crypt_autosign", DT_BOOL, R_NONE, OPT_CRYPT_AUTOSIGN, 0 },
/*
** .pp
- ** Setting this variable will cause Mutt to always attempt to
+ ** Setting this variable will cause NeoMutt to always attempt to
** cryptographically sign outgoing messages. This can be overridden
** by use of the pgp menu, when signing is not required or
** encryption is requested as well. If $$smime_is_default is \fIset\fP,
{ "crypt_autosmime", DT_BOOL, R_NONE, OPT_CRYPT_AUTOSMIME, 1 },
/*
** .pp
- ** This variable controls whether or not mutt may automatically enable
+ ** This variable controls whether or not NeoMutt may automatically enable
** S/MIME encryption/signing for messages. See also $$crypt_autoencrypt,
** $$crypt_replyencrypt,
** $$crypt_autosign, $$crypt_replysign and $$smime_is_default.
{ "crypt_opportunistic_encrypt", DT_BOOL, R_NONE, OPT_CRYPT_OPPORTUNISTIC_ENCRYPT, 0 },
/*
** .pp
- ** Setting this variable will cause Mutt to automatically enable and
+ ** Setting this variable will cause NeoMutt to automatically enable and
** disable encryption, based on whether all message recipient keys
- ** can be located by Mutt.
+ ** can be located by NeoMutt.
** .pp
- ** When this option is enabled, Mutt will enable/disable encryption
+ ** When this option is enabled, NeoMutt will enable/disable encryption
** each time the TO, CC, and BCC lists are edited. If
- ** $$edit_headers is set, Mutt will also do so each time the message
+ ** $$edit_headers is set, NeoMutt will also do so each time the message
** is edited.
** .pp
** While this is set, encryption can't be manually enabled/disabled.
** which are encrypted. This makes sense in combination with
** $$crypt_replyencrypt, because it allows you to sign all
** messages which are automatically encrypted. This works around
- ** the problem noted in $$crypt_replysign, that mutt is not able
+ ** the problem noted in $$crypt_replysign, that NeoMutt is not able
** to find out whether an encrypted message is also signed.
** (Crypto only)
*/
{ "crypt_timestamp", DT_BOOL, R_NONE, OPT_CRYPT_TIMESTAMP, 1 },
/*
** .pp
- ** If \fIset\fP, mutt will include a time stamp in the lines surrounding
+ ** If \fIset\fP, NeoMutt will include a time stamp in the lines surrounding
** PGP or S/MIME output, so spoofing such lines is more difficult.
** If you are using colors to mark these lines, and rely on these,
** you may \fIunset\fP this setting.
/*
** .pp
** This variable controls the use of the GPGME-enabled crypto backends.
- ** If it is \fIset\fP and Mutt was built with gpgme support, the gpgme code for
+ ** If it is \fIset\fP and NeoMutt was built with gpgme support, the gpgme code for
** S/MIME and PGP will be used instead of the classic code. Note that
** you need to set this option in .muttrc; it won't have any effect when
** used interactively.
{ "crypt_use_pka", DT_BOOL, R_NONE, OPT_CRYPT_USE_PKA, 0 },
/*
** .pp
- ** Controls whether mutt uses PKA
+ ** Controls whether NeoMutt uses PKA
** (see http://www.g10code.de/docs/pka-intro.de.pdf) during signature
** verification (only supported by the GPGME backend).
*/
/*
** .pp
** The debug level. Note: to debug the early startup process (before the
- ** configuration is loaded), ``-d'' mutt argument must be used.
+ ** configuration is loaded), ``-d'' neomutt argument must be used.
** debug_level/debug_file are ignored until it's read from the configuration
** file.
*/
{ "delete_untag", DT_BOOL, R_NONE, OPT_DELETE_UNTAG, 1 },
/*
** .pp
- ** If this option is \fIset\fP, mutt will untag messages when marking them
+ ** If this option is \fIset\fP, NeoMutt will untag messages when marking them
** for deletion. This applies when you either explicitly delete a message,
** or when you save it to another folder.
*/
{ "digest_collapse", DT_BOOL, R_NONE, OPT_DIGEST_COLLAPSE, 1 },
/*
** .pp
- ** If this option is \fIset\fP, mutt's received-attachments menu will not show the subparts of
+ ** If this option is \fIset\fP, NeoMutt's received-attachments menu will not show the subparts of
** individual messages in a multipart/digest. To see these subparts, press ``v'' on that menu.
*/
{ "display_filter", DT_PATH, R_PAGER, UL &DisplayFilter, UL "" },
{ "duplicate_threads", DT_BOOL, R_RESORT|R_RESORT_INIT|R_INDEX, OPT_DUPLICATE_THREADS, 1 },
/*
** .pp
- ** This variable controls whether mutt, when $$sort is set to \fIthreads\fP, threads
+ ** This variable controls whether NeoMutt, when $$sort is set to \fIthreads\fP, threads
** messages with the same Message-Id together. If it is \fIset\fP, it will indicate
** that it thinks they are duplicates of each other with an equals sign
** in the thread tree.
** labels passed to your editor will be standard RFC2822 headers,
** (e.g. To:, Cc:, Subject:). Headers added in your editor must
** also be RFC2822 headers, or one of the pseudo headers listed in
- ** ``$edit-header''. Mutt will not understand localized header
+ ** ``$edit-header''. NeoMutt will not understand localized header
** labels, just as it would not when parsing an actual email.
** .pp
** \fBNote\fP that changes made to the References: and Date: headers are
{ "editor", DT_PATH, R_NONE, UL &Editor, 0 },
/*
** .pp
- ** This variable specifies which editor is used by mutt.
+ ** This variable specifies which editor is used by NeoMutt.
** It defaults to the value of the \fC$$$VISUAL\fP, or \fC$$$EDITOR\fP, environment
** variable, or to the string ``vi'' if neither of those are set.
** .pp
{ "encode_from", DT_BOOL, R_NONE, OPT_ENCODE_FROM, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will quoted-printable encode messages when
+ ** When \fIset\fP, NeoMutt will quoted-printable encode messages when
** they contain the string ``From '' (note the trailing space) in the beginning of a line.
** This is useful to avoid the tampering certain mail delivery and transport
** agents tend to do with messages (in order to prevent tools from
/*
** .pp
** Controls whether or not the ``Mail-Followup-To:'' header field is
- ** generated when sending mail. When \fIset\fP, Mutt will generate this
+ ** generated when sending mail. When \fIset\fP, NeoMutt will generate this
** field when you are replying to a known mailing list, specified with
** the ``$subscribe'' or ``$lists'' commands.
** .pp
{ "force_name", DT_BOOL, R_NONE, OPT_FORCE_NAME, 0 },
/*
** .pp
- ** This variable is similar to $$save_name, except that Mutt will
+ ** This variable is similar to $$save_name, except that NeoMutt will
** store a copy of your outgoing message by the username of the address
** you are sending to even if that mailbox does not exist.
** .pp
** added in a particular case, use the special value CR (aka ^M)
** for the corresponding character.
** .pp
- ** This slightly odd interface is necessitated by mutt's handling of
+ ** This slightly odd interface is necessitated by NeoMutt's handling of
** string variables; one cannot tell a variable that is unset from one
** that is set to the empty string.
*/
{ "gecos_mask", DT_REGEX, R_NONE, UL &GecosMask, UL "^[^,]*" },
/*
** .pp
- ** A regular expression used by mutt to parse the GECOS field of a password
+ ** A regular expression used by NeoMutt to parse the GECOS field of a password
** entry when expanding the alias. The default value
** will return the string up to the first ``,'' encountered.
** If the GECOS field contains a string like ``lastname, firstname'' then you
** should set it to ``\fC.*\fP''.
** .pp
** This can be useful if you see the following behavior: you address an e-mail
- ** to user ID ``stevef'' whose full name is ``Steve Franklin''. If mutt expands
+ ** to user ID ``stevef'' whose full name is ``Steve Franklin''. If NeoMutt expands
** ``stevef'' to ``"Franklin" stevef@foo.bar'' then you should set the $$gecos_mask to
- ** a regular expression that will match the whole name so mutt will expand
+ ** a regular expression that will match the whole name so NeoMutt will expand
** ``Franklin'' to ``Franklin, Steve''.
*/
#ifdef USE_NNTP
{ "header", DT_BOOL, R_NONE, OPT_HEADER, 0 },
/*
** .pp
- ** When \fIset\fP, this variable causes Mutt to include the header
+ ** When \fIset\fP, this variable causes NeoMutt to include the header
** of the message you are replying to into the edit buffer.
** The $$weed setting applies.
*/
/*
** .pp
** This variable points to the header cache database.
- ** If pointing to a directory Mutt will contain a header cache
+ ** If pointing to a directory NeoMutt will contain a header cache
** database file per folder, if pointing to a file that file will
** be a single global header cache. By default it is \fIunset\fP so no header
** caching will be used.
{ "header_cache_compress", DT_BOOL, R_NONE, OPT_HEADER_CACHE_COMPRESS, 1 },
/*
** .pp
- ** When mutt is compiled with qdbm, tokyocabinet or kyotocabinet
+ ** When NeoMutt is compiled with qdbm, tokyocabinet or kyotocabinet
** as header cache backend, this option determines whether the
** database will be compressed. Compression results in database
** files roughly being one fifth of the usual diskspace, but the
{ "header_cache_pagesize", DT_STRING, R_NONE, UL &HeaderCachePageSize, UL "16384" },
/*
** .pp
- ** When mutt is compiled with either gdbm or bdb4 as the header cache backend,
+ ** When NeoMutt is compiled with either gdbm or bdb4 as the header cache backend,
** this option changes the database page size. Too large or too small
** values can waste space, memory, or CPU time. The default should be more
** or less optimal for most use cases.
** .pp
** \fBNote:\fP The binding will not be displayed correctly if the
** function is bound to a sequence rather than a single keystroke. Also,
- ** the help line may not be updated if a binding is changed while Mutt is
+ ** the help line may not be updated if a binding is changed while NeoMutt is
** running. Since this variable is primarily aimed at new users, neither
** of these should present a major problem.
*/
{ "hidden_host", DT_BOOL, R_NONE, OPT_HIDDEN_HOST, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will skip the host name part of $$hostname variable
+ ** When \fIset\fP, NeoMutt will skip the host name part of $$hostname variable
** when adding the domain part to addresses. This variable does not
** affect the generation of Message-IDs, and it will not lead to the
** cut-off of first-level domains.
{ "hide_limited", DT_BOOL, R_TREE|R_INDEX, OPT_HIDE_LIMITED, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will not show the presence of messages that are hidden
+ ** When \fIset\fP, NeoMutt will not show the presence of messages that are hidden
** by limiting, in the thread tree.
*/
{ "hide_missing", DT_BOOL, R_TREE|R_INDEX, OPT_HIDE_MISSING, 1 },
/*
** .pp
- ** When \fIset\fP, mutt will not show the presence of missing messages in the
+ ** When \fIset\fP, NeoMutt will not show the presence of missing messages in the
** thread tree.
*/
{ "hide_thread_subject", DT_BOOL, R_TREE|R_INDEX, OPT_HIDE_THREAD_SUBJECT, 1 },
/*
** .pp
- ** When \fIset\fP, mutt will not show the subject of messages in the thread
+ ** When \fIset\fP, NeoMutt will not show the subject of messages in the thread
** tree that have the same subject as their parent or closest previously
** displayed sibling.
*/
{ "hide_top_limited", DT_BOOL, R_TREE|R_INDEX, OPT_HIDE_TOP_LIMITED, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will not show the presence of messages that are hidden
+ ** When \fIset\fP, NeoMutt will not show the presence of messages that are hidden
** by limiting, at the top of threads in the thread tree. Note that when
** $$hide_limited is \fIset\fP, this option will have no effect.
*/
{ "hide_top_missing", DT_BOOL, R_TREE|R_INDEX, OPT_HIDE_TOP_MISSING, 1 },
/*
** .pp
- ** When \fIset\fP, mutt will not show the presence of missing messages at the
+ ** When \fIset\fP, NeoMutt will not show the presence of missing messages at the
** top of threads in the thread tree. Note that when $$hide_missing is
** \fIset\fP, this option will have no effect.
*/
{ "history_file", DT_PATH, R_NONE, UL &HistoryFile, UL "~/.mutthistory" },
/*
** .pp
- ** The file in which Mutt will save its history.
+ ** The file in which NeoMutt will save its history.
** .pp
** Also see $$save_history.
*/
{ "honor_disposition", DT_BOOL, R_NONE, OPT_HONOR_DISPOSITION, 0 },
/*
** .pp
- ** When \fIset\fP, Mutt will not display attachments with a
+ ** When \fIset\fP, NeoMutt will not display attachments with a
** disposition of ``attachment'' inline even if it could
** render the part to plain text. These MIME parts can only
** be viewed from the attachment menu.
** .pp
- ** If \fIunset\fP, Mutt will render all MIME parts it can
+ ** If \fIunset\fP, NeoMutt will render all MIME parts it can
** properly transform to plain text.
*/
{ "honor_followup_to", DT_QUAD, R_NONE, OPT_HONOR_FOLLOWUP_TO, MUTT_YES },
{ "hostname", DT_STRING, R_NONE, UL &Hostname, 0 },
/*
** .pp
- ** Specifies the fully-qualified hostname of the system mutt is running on
+ ** Specifies the fully-qualified hostname of the system NeoMutt is running on
** containing the host's name and the DNS domain it belongs to. It is used
** as the domain part (after ``@'') for local email addresses as well as
** Message-Id headers.
** domain is then looked up using the \fCgethostname(2)\fP and
** \fCgetaddrinfo(3)\fP functions. If those calls are unable to
** determine the domain, the full value returned by uname is used.
- ** Optionally, Mutt can be compiled with a fixed domain name in
+ ** Optionally, NeoMutt can be compiled with a fixed domain name in
** which case a detected one is not used.
** .pp
** Also see $$use_domain and $$hidden_host.
{ "idn_decode", DT_BOOL, R_MENU, OPT_IDN_DECODE, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will show you international domain names decoded.
+ ** When \fIset\fP, NeoMutt will show you international domain names decoded.
** Note: You can use IDNs for addresses even if this is \fIunset\fP.
** This variable only affects decoding. (IDN only)
*/
{ "idn_encode", DT_BOOL, R_MENU, OPT_IDN_ENCODE, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will encode international domain names using
+ ** When \fIset\fP, NeoMutt will encode international domain names using
** IDN. Unset this if your SMTP server can handle newer (RFC6531)
** UTF-8 encoded domains. (IDN only)
*/
** Affects the behavior of the \fC<reply>\fP function when replying to
** messages from mailing lists (as defined by the ``$subscribe'' or
** ``$lists'' commands). When \fIset\fP, if the ``Reply-To:'' field is
- ** set to the same value as the ``To:'' field, Mutt assumes that the
+ ** set to the same value as the ``To:'' field, NeoMutt assumes that the
** ``Reply-To:'' field was set by the mailing list to automate responses
** to the list, and will ignore this field. To direct a response to the
** mailing list when this option is \fIset\fP, use the \fC$<list-reply>\fP
{ "imap_authenticators", DT_STRING, R_NONE, UL &ImapAuthenticators, UL 0 },
/*
** .pp
- ** This is a colon-delimited list of authentication methods mutt may
- ** attempt to use to log in to an IMAP server, in the order mutt should
+ ** This is a colon-delimited list of authentication methods NeoMutt may
+ ** attempt to use to log in to an IMAP server, in the order NeoMutt should
** try them. Authentication methods are either ``login'' or the right
** side of an IMAP ``AUTH=xxx'' capability string, e.g. ``digest-md5'', ``gssapi''
** or ``cram-md5''. This option is case-insensitive. If it's
- ** \fIunset\fP (the default) mutt will try all available methods,
+ ** \fIunset\fP (the default) NeoMutt will try all available methods,
** in order from most-secure to least-secure.
** .pp
** Example:
** set imap_authenticators="gssapi:cram-md5:login"
** .te
** .pp
- ** \fBNote:\fP Mutt will only fall back to other authentication methods if
+ ** \fBNote:\fP NeoMutt will only fall back to other authentication methods if
** the previous methods are unavailable. If a method is available but
- ** authentication fails, mutt will not connect to the IMAP server.
+ ** authentication fails, NeoMutt will not connect to the IMAP server.
*/
{ "imap_check_subscribed", DT_BOOL, R_NONE, OPT_IMAP_CHECK_SUBSCRIBED, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will fetch the set of subscribed folders from
+ ** When \fIset\fP, NeoMutt will fetch the set of subscribed folders from
** your server on connection, and add them to the set of mailboxes
** it polls for new mail just as if you had issued individual ``$mailboxes''
** commands.
{ "imap_headers", DT_STRING, R_INDEX, UL &ImapHeaders, UL 0 },
/*
** .pp
- ** Mutt requests these header fields in addition to the default headers
+ ** NeoMutt requests these header fields in addition to the default headers
** (``Date:'', ``From:'', ``Subject:'', ``To:'', ``Cc:'', ``Message-Id:'',
** ``References:'', ``Content-Type:'', ``Content-Description:'', ``In-Reply-To:'',
** ``Reply-To:'', ``Lines:'', ``List-Post:'', ``X-Label:'') from IMAP
{ "imap_idle", DT_BOOL, R_NONE, OPT_IMAP_IDLE, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will attempt to use the IMAP IDLE extension
+ ** When \fIset\fP, NeoMutt will attempt to use the IMAP IDLE extension
** to check for new mail in the current mailbox. Some servers
** (dovecot was the inspiration for this option) react badly
- ** to mutt's implementation. If your connection seems to freeze
+ ** to NeoMutt's implementation. If your connection seems to freeze
** up periodically, try unsetting this.
*/
{ "imap_keepalive", DT_NUMBER, R_NONE, UL &ImapKeepalive, 300 },
/*
** .pp
- ** This variable specifies the maximum amount of time in seconds that mutt
+ ** This variable specifies the maximum amount of time in seconds that NeoMutt
** will wait before polling open IMAP connections, to prevent the server
- ** from closing them before mutt has finished with them. The default is
+ ** from closing them before NeoMutt has finished with them. The default is
** well within the RFC-specified minimum amount of time (30 minutes) before
** a server is allowed to do this, but in practice the RFC does get
** violated every now and then. Reduce this number if you find yourself
{ "imap_pass", DT_STRING, R_NONE|F_SENSITIVE, UL &ImapPass, UL 0 },
/*
** .pp
- ** Specifies the password for your IMAP account. If \fIunset\fP, Mutt will
+ ** Specifies the password for your IMAP account. If \fIunset\fP, NeoMutt will
** prompt you for your password when you invoke the \fC<imap-fetch-mail>\fP function
** or try to open an IMAP folder.
** .pp
{ "imap_passive", DT_BOOL, R_NONE, OPT_IMAP_PASSIVE, 1 },
/*
** .pp
- ** When \fIset\fP, mutt will not open new IMAP connections to check for new
- ** mail. Mutt will only check for new mail over existing IMAP
+ ** When \fIset\fP, NeoMutt will not open new IMAP connections to check for new
+ ** mail. NeoMutt will only check for new mail over existing IMAP
** connections. This is useful if you don't want to be prompted to
- ** user/password pairs on mutt invocation, or if opening the connection
+ ** user/password pairs on NeoMutt invocation, or if opening the connection
** is slow.
*/
{ "imap_peek", DT_BOOL, R_NONE, OPT_IMAP_PEEK, 1 },
/*
** .pp
- ** When \fIset\fP, mutt will avoid implicitly marking your mail as read whenever
+ ** When \fIset\fP, NeoMutt will avoid implicitly marking your mail as read whenever
** you fetch a message from the server. This is generally a good thing,
** but can make closing an IMAP folder somewhat slower. This option
** exists to appease speed freaks.
** .pp
** Controls the number of IMAP commands that may be queued up before they
** are sent to the server. A deeper pipeline reduces the amount of time
- ** mutt must wait for the server, and can make IMAP servers feel much
+ ** NeoMutt must wait for the server, and can make IMAP servers feel much
** more responsive. But not all servers correctly handle pipelined commands,
** so if you have problems you might want to try setting this variable to 0.
** .pp
/*
** .pp
** This variable specifies the maximum amount of time in seconds
- ** that mutt will wait for a response when polling IMAP connections
+ ** that NeoMutt will wait for a response when polling IMAP connections
** for new mail, before timing out and closing the connection. Set
** to 0 to disable timing out.
*/
{ "imap_servernoise", DT_BOOL, R_NONE, OPT_IMAP_SERVERNOISE, 1 },
/*
** .pp
- ** When \fIset\fP, mutt will display warning messages from the IMAP
+ ** When \fIset\fP, NeoMutt will display warning messages from the IMAP
** server as error messages. Since these messages are often
** harmless, or generated due to configuration problems on the
** server which are out of the users' hands, you may wish to suppress
{ "implicit_autoview", DT_BOOL,R_NONE, OPT_IMPLICIT_AUTOVIEW, 0 },
/*
** .pp
- ** If set to ``yes'', mutt will look for a mailcap entry with the
+ ** If set to ``yes'', NeoMutt will look for a mailcap entry with the
** ``\fCcopiousoutput\fP'' flag set for \fIevery\fP MIME attachment it doesn't have
- ** an internal viewer defined for. If such an entry is found, mutt will
+ ** an internal viewer defined for. If such an entry is found, NeoMutt will
** use the viewer defined in that entry to convert the body part to text
** form.
*/
{ "include_onlyfirst", DT_BOOL, R_NONE, OPT_INCLUDE_ONLYFIRST, 0 },
/*
** .pp
- ** Controls whether or not Mutt includes only the first attachment
+ ** Controls whether or not NeoMutt includes only the first attachment
** of the message you are replying.
*/
{ "indent_string", DT_STRING, R_NONE, UL &IndentString, UL "> " },
** ``Format strings'' are similar to the strings used in the C
** function \fCprintf(3)\fP to format output (see the man page for more details).
** For an explanation of the %? construct, see the $status_format description.
- ** The following sequences are defined in Mutt:
+ ** The following sequences are defined in NeoMutt:
** .dl
** .dt %a .dd address of the author
** .dt %A .dd reply-to address (if present; otherwise: address of author)
** .dt %M .dd number of hidden messages if the thread is collapsed.
** .dt %N .dd message score
** .dt %n .dd author's real name (or address if missing)
- ** .dt %O .dd original save folder where mutt would formerly have
+ ** .dt %O .dd original save folder where NeoMutt would formerly have
** stashed the message: list name or recipient name
** if not sent to a list
** .dt %P .dd progress indicator for the built-in pager (how much of the file has been displayed)
/*
** .pp
** If set, specifies the program and arguments used to deliver news posted
- ** by Mutt. Otherwise, mutt posts article using current connection to
+ ** by NeoMutt. Otherwise, NeoMutt posts article using current connection to
** news server. The following printf-style sequence is understood:
** .dl
** .dt %a .dd account url
** they were sourced from.
** .pp
** If both ``$$keywords_legacy'' and
- ** ``$$keywords_standard'' are \fCfalse\fP, mutt will save keywords
+ ** ``$$keywords_standard'' are \fCfalse\fP, NeoMutt will save keywords
** to legacy headers to ensure that it does not lose your labels.
*/
{ "keywords_standard", DT_BOOL, R_NONE, OPT_KEYWORDS_STANDARD, 0 },
** legacy headers.
** .pp
** If both ``$$keywords_legacy'' and
- ** ``$$keywords_standard'' are \fCfalse\fP, mutt will save keywords
+ ** ``$$keywords_standard'' are \fCfalse\fP, NeoMutt will save keywords
** to legacy headers to ensure that it does not lose your labels.
*/
{ "mail_check", DT_NUMBER, R_NONE, UL &MailCheck, 5 },
/*
** .pp
- ** This variable configures how often (in seconds) mutt should look for
+ ** This variable configures how often (in seconds) NeoMutt should look for
** new mail. Also see the $$timeout variable.
*/
{ "mail_check_recent",DT_BOOL, R_NONE, OPT_MAIL_CHECK_RECENT, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will only notify you about new mail that has been received
- ** since the last time you opened the mailbox. When \fIunset\fP, Mutt will notify you
+ ** When \fIset\fP, NeoMutt will only notify you about new mail that has been received
+ ** since the last time you opened the mailbox. When \fIunset\fP, NeoMutt will notify you
** if any new mail exists in the mailbox, regardless of whether you have visited it
** recently.
** .pp
- ** When \fI$$mark_old\fP is set, Mutt does not consider the mailbox to contain new
+ ** When \fI$$mark_old\fP is set, NeoMutt does not consider the mailbox to contain new
** mail if only old messages exist.
*/
{ "mail_check_stats", DT_BOOL, R_NONE, OPT_MAIL_CHECK_STATS, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will periodically calculate message
+ ** When \fIset\fP, NeoMutt will periodically calculate message
** statistics of a mailbox while polling for new mail. It will
** check for unread, flagged, and total message counts. Because
** this operation is more performance intensive, it defaults to
/*
** .pp
** When $$mail_check_stats is \fIset\fP, this variable configures
- ** how often (in seconds) mutt will update message counts.
+ ** how often (in seconds) NeoMutt will update message counts.
*/
{ "mailcap_path", DT_STRING, R_NONE, UL &MailcapPath, 0 },
/*
** .pp
** This variable specifies which files to consult when attempting to
- ** display MIME bodies not directly supported by Mutt.
+ ** display MIME bodies not directly supported by NeoMutt.
*/
{ "mailcap_sanitize", DT_BOOL, R_NONE, OPT_MAILCAP_SANITIZE, 1 },
/*
** .pp
- ** If \fIset\fP, mutt will restrict possible characters in mailcap % expandos
+ ** If \fIset\fP, NeoMutt will restrict possible characters in mailcap % expandos
** to a well-defined set of safe characters. This is the safe setting,
** but we are not sure it doesn't break some more advanced MIME stuff.
** .pp
{ "maildir_header_cache_verify", DT_BOOL, R_NONE, OPT_MAILDIR_HEADER_CACHE_VERIFY, 1 },
/*
** .pp
- ** Check for Maildir unaware programs other than mutt having modified maildir
+ ** Check for Maildir unaware programs other than NeoMutt having modified maildir
** files when the header cache is in use. This incurs one \fCstat(2)\fP per
** message every time the folder is opened (which can be very slow for NFS
** folders).
{ "maildir_check_cur", DT_BOOL, R_NONE, OPT_MAILDIR_CHECK_CUR, 0 },
/*
** .pp
- ** If \fIset\fP, mutt will poll both the new and cur directories of
+ ** If \fIset\fP, NeoMutt will poll both the new and cur directories of
** a maildir folder for new messages. This might be useful if other
** programs interacting with the folder (e.g. dovecot) are moving new
** messages to the cur directory. Note that setting this option may
- ** slow down polling for new messages in large folders, since mutt has
+ ** slow down polling for new messages in large folders, since NeoMutt has
** to scan all cur messages.
*/
{ "mark_macro_prefix",DT_STRING, R_NONE, UL &MarkMacroPrefix, UL "'" },
{ "mark_old", DT_BOOL, R_BOTH, OPT_MARK_OLD, 1 },
/*
** .pp
- ** Controls whether or not mutt marks \fInew\fP \fBunread\fP
+ ** Controls whether or not NeoMutt marks \fInew\fP \fBunread\fP
** messages as \fIold\fP if you exit a mailbox without reading them.
- ** With this option \fIset\fP, the next time you start mutt, the messages
+ ** With this option \fIset\fP, the next time you start NeoMutt, the messages
** will show up with an ``O'' next to them in the index menu,
** indicating that they are old.
*/
{ "message_cache_clean", DT_BOOL, R_NONE, OPT_MESSAGE_CACHE_CLEAN, 0 },
/*
** .pp
- ** If \fIset\fP, mutt will clean out obsolete entries from the message cache when
+ ** If \fIset\fP, NeoMutt will clean out obsolete entries from the message cache when
** the mailbox is synchronized. You probably only want to set it
** every once in a while, since it can be a little slow
** (especially for large folders).
{ "message_cachedir", DT_PATH, R_NONE, UL &MessageCachedir, 0 },
/*
** .pp
- ** Set this to a directory and mutt will cache copies of messages from
+ ** Set this to a directory and NeoMutt will cache copies of messages from
** your IMAP and POP servers here. You are free to remove entries at any
** time.
** .pp
- ** When setting this variable to a directory, mutt needs to fetch every
+ ** When setting this variable to a directory, NeoMutt needs to fetch every
** remote message only once and can perform regular expression searches
** as fast as for local folders.
** .pp
{ "meta_key", DT_BOOL, R_NONE, OPT_META_KEY, 0 },
/*
** .pp
- ** If \fIset\fP, forces Mutt to interpret keystrokes with the high bit (bit 8)
+ ** If \fIset\fP, forces NeoMutt to interpret keystrokes with the high bit (bit 8)
** set as if the user had pressed the Esc key and whatever key remains
** after having the high bit removed. For example, if the key pressed
** has an ASCII value of \fC0xf8\fP, then this is treated as if the user had
{ "metoo", DT_BOOL, R_NONE, OPT_METOO, 0 },
/*
** .pp
- ** If \fIunset\fP, Mutt will remove your address (see the ``$alternates''
+ ** If \fIunset\fP, NeoMutt will remove your address (see the ``$alternates''
** command) from the list of recipients when replying to a message.
*/
{ "mh_purge", DT_BOOL, R_NONE, OPT_MH_PURGE, 0 },
/*
** .pp
- ** When \fIunset\fP, mutt will mimic mh's behavior and rename deleted messages
+ ** When \fIunset\fP, NeoMutt will mimic mh's behavior and rename deleted messages
** to \fI,<old file name>\fP in mh folders instead of really deleting
** them. This leaves the message on disk but makes programs reading the folder
** ignore it. If the variable is \fIset\fP, the message files will simply be
** attachment's extension is not found in the mime.types file.
** .pp
** The string may contain a ``%s'', which will be substituted with the
- ** attachment filename. Mutt will add quotes around the string substituted
+ ** attachment filename. NeoMutt will add quotes around the string substituted
** for ``%s'' automatically according to shell quoting rules, so you should
- ** avoid adding your own. If no ``%s'' is found in the string, Mutt will
+ ** avoid adding your own. If no ``%s'' is found in the string, NeoMutt will
** append the attachment filename to the end of the string.
** .pp
** The command should output a single line containing the
{ "move", DT_QUAD, R_NONE, OPT_MOVE, MUTT_NO },
/*
** .pp
- ** Controls whether or not Mutt will move read messages
+ ** Controls whether or not NeoMutt will move read messages
** from your spool mailbox to your $$mbox mailbox, or as a result of
** a ``$mbox-hook'' command.
*/
{ "new_mail_command", DT_PATH, R_NONE, UL &NewMailCommand, UL NULL },
/*
** .pp
- ** If \fIset\fP, Mutt will call this command after a new message is received.
+ ** If \fIset\fP, NeoMutt will call this command after a new message is received.
** See the $$status_format documentation for the values that can be formatted
** into this command.
*/
{ "news_cache_dir", DT_PATH, R_NONE, UL &NewsCacheDir, UL "~/.mutt" },
/*
** .pp
- ** This variable pointing to directory where Mutt will save cached news
+ ** This variable pointing to directory where NeoMutt will save cached news
** articles and headers in. If \fIunset\fP, articles and headers will not be
** saved at all and will be reloaded from the server each time.
*/
{ "nntp_authenticators", DT_STRING, R_NONE, UL &NntpAuthenticators, UL 0 },
/*
** .pp
- ** This is a colon-delimited list of authentication methods mutt may
- ** attempt to use to log in to a news server, in the order mutt should
+ ** This is a colon-delimited list of authentication methods NeoMutt may
+ ** attempt to use to log in to a news server, in the order NeoMutt should
** try them. Authentication methods are either ``user'' or any
** SASL mechanism, e.g. ``digest-md5'', ``gssapi'' or ``cram-md5''.
** This option is case-insensitive. If it's \fIunset\fP (the default)
- ** mutt will try all available methods, in order from most-secure to
+ ** NeoMutt will try all available methods, in order from most-secure to
** least-secure.
** .pp
** Example:
** set nntp_authenticators="digest-md5:user"
** .te
** .pp
- ** \fBNote:\fP Mutt will only fall back to other authentication methods if
+ ** \fBNote:\fP NeoMutt will only fall back to other authentication methods if
** the previous methods are unavailable. If a method is available but
- ** authentication fails, mutt will not connect to the IMAP server.
+ ** authentication fails, NeoMutt will not connect to the IMAP server.
*/
{ "nntp_context", DT_NUMBER, R_NONE, UL &NntpContext, 1000 },
/*
/*
** .pp
** Your login name on the NNTP server. If \fIunset\fP and NNTP server requires
- ** authentication, Mutt will prompt you for your account name when you
+ ** authentication, NeoMutt will prompt you for your account name when you
** connect to news server.
*/
{ "nntp_pass", DT_STRING, R_NONE|F_SENSITIVE, UL &NntpPass, UL "" },
/*
** .pp
** The time in seconds until any operations on newsgroup except post new
- ** article will cause recheck for new news. If set to 0, Mutt will
+ ** article will cause recheck for new news. If set to 0, NeoMutt will
** recheck newsgroup on each operation in index (stepping, read article,
** etc.).
*/
/*
** .pp
** The messages tagged with these tags are excluded and not loaded
- ** from notmuch DB to mutt unless specified explicitly.
+ ** from notmuch DB to NeoMutt unless specified explicitly.
*/
{ "nm_unread_tag", DT_STRING, R_NONE, UL &NmUnreadTag, UL "unread" },
/*
** .pp
** This variable specifies notmuch tag which is used for unread messages. The
- ** variable is used to count unread messages in DB only. All other mutt commands
+ ** variable is used to count unread messages in DB only. All other NeoMutt commands
** use standard (e.g. maildir) flags.
*/
{ "nm_db_limit", DT_NUMBER, R_NONE, UL &NmDbLimit, 0 },
{ "nm_record", DT_BOOL, R_NONE, OPT_NM_RECORD, 0 },
/*
** .pp
- ** This variable specifies if the mutt record should indexed by notmuch.
+ ** This variable specifies if the NeoMutt record should indexed by notmuch.
*/
{ "nm_record_tags", DT_STRING, R_NONE, UL &NmRecordTags, 0 },
/*
** .pp
- ** This variable specifies the default tags applied to messages stored to the mutt record.
+ ** This variable specifies the default tags applied to messages stored to the NeoMutt record.
** When set to 0 this variable disable the window feature.
*/
{ "nm_query_window_duration", DT_NUMBER, R_NONE, UL &NmQueryWindowDuration, 0 },
** like to use.
** .pp
** Using an external pager may have some disadvantages: Additional
- ** keystrokes are necessary because you can't call mutt functions
+ ** keystrokes are necessary because you can't call NeoMutt functions
** directly from the pager, and screen resizes cause lines longer than
** the screen width to be badly formatted in the help menu.
*/
** .pp
** This variable controls the number of lines of context that are given
** when displaying the next or previous page in the internal pager. By
- ** default, Mutt will display the line after the last one on the screen
+ ** default, NeoMutt will display the line after the last one on the screen
** at the top of the next page (0 lines of context).
** .pp
** This variable also specifies the amount of context given for search
{ "pgp_auto_decode", DT_BOOL, R_NONE, OPT_PGP_AUTO_DECODE, 0 },
/*
** .pp
- ** If \fIset\fP, mutt will automatically attempt to decrypt traditional PGP
+ ** If \fIset\fP, NeoMutt will automatically attempt to decrypt traditional PGP
** messages whenever the user performs an operation which ordinarily would
** result in the contents of the message being operated on. For example,
** if the user displays a pgp-traditional message which has not been manually
- ** checked with the \fC$<check-traditional-pgp>\fP function, mutt will automatically
+ ** checked with the \fC$<check-traditional-pgp>\fP function, NeoMutt will automatically
** check the message for traditional pgp.
*/
{ "pgp_create_traditional", DT_SYNONYM, R_NONE, UL "pgp_autoinline", 0 },
{ "pgp_autoinline", DT_BOOL, R_NONE, OPT_PGP_AUTOINLINE, 0 },
/*
** .pp
- ** This option controls whether Mutt generates old-style inline
+ ** This option controls whether NeoMutt generates old-style inline
** (traditional) PGP encrypted or signed messages under certain
** circumstances. This can be overridden by use of the pgp menu,
** when inline is not required. The GPGME backend does not support
** this option.
** .pp
- ** Note that Mutt might automatically use PGP/MIME for messages
- ** which consist of more than a single MIME part. Mutt can be
+ ** Note that NeoMutt might automatically use PGP/MIME for messages
+ ** which consist of more than a single MIME part. NeoMutt can be
** configured to ask before sending PGP/MIME messages when inline
** (traditional) would not work.
** .pp
{ "pgp_check_exit", DT_BOOL, R_NONE, OPT_PGP_CHECK_EXIT, 1 },
/*
** .pp
- ** If \fIset\fP, mutt will check the exit code of the PGP subprocess when
+ ** If \fIset\fP, NeoMutt will check the exit code of the PGP subprocess when
** signing or encrypting. A non-zero exit code means that the
** subprocess failed.
** (PGP only)
{ "pgp_getkeys_command", DT_STRING, R_NONE, UL &PgpGetkeysCommand, 0 },
/*
** .pp
- ** This command is invoked whenever Mutt needs to fetch the public key associated with
+ ** This command is invoked whenever NeoMutt needs to fetch the public key associated with
** an email address. Of the sequences supported by $$pgp_decode_command, %r is
** the only \fCprintf(3)\fP-like sequence used with this format. Note that
** in this case, %r expands to the email address, not the public key ID (the key ID is
- ** unknown, which is why Mutt is invoking this command).
+ ** unknown, which is why NeoMutt is invoking this command).
** (PGP only)
*/
{ "pgp_good_sign", DT_REGEX, R_NONE, UL &PgpGoodSign, 0 },
{ "pgp_ignore_subkeys", DT_BOOL, R_NONE, OPT_PGP_IGNORE_SUBKEYS, 1 },
/*
** .pp
- ** Setting this variable will cause Mutt to ignore OpenPGP subkeys. Instead,
+ ** Setting this variable will cause NeoMutt to ignore OpenPGP subkeys. Instead,
** the principal key will inherit the subkeys' capabilities. \fIUnset\fP this
** if you want to play interesting key selection games.
** (PGP only)
** .te
** .pp
** This format is also generated by the \fCpgpring\fP utility which comes
- ** with mutt.
+ ** with NeoMutt.
** .pp
** Note: gpg's \fCfixed-list-mode\fP option should not be used. It
- ** produces a different date format which may result in mutt showing
+ ** produces a different date format which may result in NeoMutt showing
** incorrect key generation dates.
** .pp
** This is a format string, see the $$pgp_decode_command command for
** .te
** .pp
** This format is also generated by the \fCpgpring\fP utility which comes
- ** with mutt.
+ ** with NeoMutt.
** .pp
** Note: gpg's \fCfixed-list-mode\fP option should not be used. It
- ** produces a different date format which may result in mutt showing
+ ** produces a different date format which may result in NeoMutt showing
** incorrect key generation dates.
** .pp
** This is a format string, see the $$pgp_decode_command command for
/*
** .pp
** If \fIset\fP, use 64 bit PGP key IDs, if \fIunset\fP use the normal 32 bit key IDs.
- ** NOTE: Internally, Mutt has transitioned to using fingerprints (or long key IDs
+ ** NOTE: Internally, NeoMutt has transitioned to using fingerprints (or long key IDs
** as a fallback). This option now only controls the display of key IDs
** in the key selection menu and a few other places.
** (PGP only)
{ "pgp_mime_auto", DT_QUAD, R_NONE, OPT_PGP_MIME_AUTO, MUTT_ASKYES },
/*
** .pp
- ** This option controls whether Mutt will prompt you for
+ ** This option controls whether NeoMutt will prompt you for
** automatically sending a (signed/encrypted) message using
** PGP/MIME when inline (traditional) fails (for any reason).
** .pp
{ "pgp_replyinline", DT_BOOL, R_NONE, OPT_PGP_REPLYINLINE, 0 },
/*
** .pp
- ** Setting this variable will cause Mutt to always attempt to
+ ** Setting this variable will cause NeoMutt to always attempt to
** create an inline (traditional) message when replying to a
** message which is PGP encrypted/signed inline. This can be
** overridden by use of the pgp menu, when inline is not
** required. This option does not automatically detect if the
- ** (replied-to) message is inline; instead it relies on Mutt
+ ** (replied-to) message is inline; instead it relies on NeoMutt
** internals for previously checked/flagged messages.
** .pp
- ** Note that Mutt might automatically use PGP/MIME for messages
- ** which consist of more than a single MIME part. Mutt can be
+ ** Note that NeoMutt might automatically use PGP/MIME for messages
+ ** which consist of more than a single MIME part. NeoMutt can be
** configured to ask before sending PGP/MIME messages when inline
** (traditional) would not work.
** .pp
{ "pgp_show_unusable", DT_BOOL, R_NONE, OPT_PGP_SHOW_UNUSABLE, 1 },
/*
** .pp
- ** If \fIset\fP, mutt will display non-usable keys on the PGP key selection
+ ** If \fIset\fP, NeoMutt will display non-usable keys on the PGP key selection
** menu. This includes keys which have been revoked, have expired, or
** have been marked as ``disabled'' by the user.
** (PGP only)
{ "pgp_strict_enc", DT_BOOL, R_NONE, OPT_PGP_STRICT_ENC, 1 },
/*
** .pp
- ** If \fIset\fP, Mutt will automatically encode PGP/MIME signed messages as
+ ** If \fIset\fP, NeoMutt will automatically encode PGP/MIME signed messages as
** quoted-printable. Please note that unsetting this variable may
** lead to problems with non-verifyable PGP signatures, so only change
** this if you know what you are doing.
{ "pgp_use_gpg_agent", DT_BOOL, R_NONE, OPT_PGP_USE_GPG_AGENT, 0 },
/*
** .pp
- ** If \fIset\fP, mutt will use a possibly-running \fCgpg-agent(1)\fP process.
+ ** If \fIset\fP, NeoMutt will use a possibly-running \fCgpg-agent(1)\fP process.
** Note that as of version 2.1, GnuPG no longer exports GPG_AGENT_INFO, so
- ** mutt no longer verifies if the agent is running.
+ ** NeoMutt no longer verifies if the agent is running.
** (PGP only)
*/
{ "pgp_verify_command", DT_STRING, R_NONE, UL &PgpVerifyCommand, 0 },
/*
** .pp
** Used in connection with the \fC<pipe-message>\fP command. When \fIunset\fP,
- ** Mutt will pipe the messages without any preprocessing. When \fIset\fP, Mutt
+ ** NeoMutt will pipe the messages without any preprocessing. When \fIset\fP, NeoMutt
** will weed headers and will attempt to decode the messages
** first.
*/
** .pp
** Used in connection with the \fC<pipe-message>\fP function following
** \fC<tag-prefix>\fP. If this variable is \fIunset\fP, when piping a list of
- ** tagged messages Mutt will concatenate the messages and will pipe them
- ** all concatenated. When \fIset\fP, Mutt will pipe the messages one by one.
+ ** tagged messages NeoMutt will concatenate the messages and will pipe them
+ ** all concatenated. When \fIset\fP, NeoMutt will pipe the messages one by one.
** In both cases the messages are piped in the current sorted order,
** and the $$pipe_sep separator is added after each message.
*/
{ "pop_auth_try_all", DT_BOOL, R_NONE, OPT_POP_AUTH_TRY_ALL, 1 },
/*
** .pp
- ** If \fIset\fP, Mutt will try all available authentication methods.
- ** When \fIunset\fP, Mutt will only fall back to other authentication
+ ** If \fIset\fP, NeoMutt will try all available authentication methods.
+ ** When \fIunset\fP, NeoMutt will only fall back to other authentication
** methods if the previous methods are unavailable. If a method is
- ** available but authentication fails, Mutt will not connect to the POP server.
+ ** available but authentication fails, NeoMutt will not connect to the POP server.
*/
{ "pop_authenticators", DT_STRING, R_NONE, UL &PopAuthenticators, UL 0 },
/*
** .pp
- ** This is a colon-delimited list of authentication methods mutt may
- ** attempt to use to log in to an POP server, in the order mutt should
+ ** This is a colon-delimited list of authentication methods NeoMutt may
+ ** attempt to use to log in to an POP server, in the order NeoMutt should
** try them. Authentication methods are either ``user'', ``apop'' or any
** SASL mechanism, e.g. ``digest-md5'', ``gssapi'' or ``cram-md5''.
** This option is case-insensitive. If this option is \fIunset\fP
- ** (the default) mutt will try all available methods, in order from
+ ** (the default) NeoMutt will try all available methods, in order from
** most-secure to least-secure.
** .pp
** Example:
{ "pop_checkinterval", DT_NUMBER, R_NONE, UL &PopCheckinterval, 60 },
/*
** .pp
- ** This variable configures how often (in seconds) mutt should look for
+ ** This variable configures how often (in seconds) NeoMutt should look for
** new mail in the currently selected mailbox if it is a POP mailbox.
*/
{ "pop_delete", DT_QUAD, R_NONE, OPT_POP_DELETE, MUTT_ASKNO },
/*
** .pp
- ** If \fIset\fP, Mutt will delete successfully downloaded messages from the POP
- ** server when using the \fC$<fetch-mail>\fP function. When \fIunset\fP, Mutt will
+ ** If \fIset\fP, NeoMutt will delete successfully downloaded messages from the POP
+ ** server when using the \fC$<fetch-mail>\fP function. When \fIunset\fP, NeoMutt will
** download messages but also leave them on the POP server.
*/
{ "pop_host", DT_STRING, R_NONE, UL &PopHost, UL "" },
{ "pop_last", DT_BOOL, R_NONE, OPT_POP_LAST, 0 },
/*
** .pp
- ** If this variable is \fIset\fP, mutt will try to use the ``\fCLAST\fP'' POP command
+ ** If this variable is \fIset\fP, NeoMutt will try to use the ``\fCLAST\fP'' POP command
** for retrieving only unread messages from the POP server when using
** the \fC$<fetch-mail>\fP function.
*/
{ "pop_pass", DT_STRING, R_NONE|F_SENSITIVE, UL &PopPass, UL "" },
/*
** .pp
- ** Specifies the password for your POP account. If \fIunset\fP, Mutt will
+ ** Specifies the password for your POP account. If \fIunset\fP, NeoMutt will
** prompt you for your password when you open a POP mailbox.
** .pp
** \fBWarning\fP: you should only use this option when you are on a
{ "pop_reconnect", DT_QUAD, R_NONE, OPT_POP_RECONNECT, MUTT_ASKYES },
/*
** .pp
- ** Controls whether or not Mutt will try to reconnect to the POP server if
+ ** Controls whether or not NeoMutt will try to reconnect to the POP server if
** the connection is lost.
*/
{ "pop_user", DT_STRING, R_NONE|F_SENSITIVE, UL &PopUser, 0 },
{ "post_indent_string",DT_STRING, R_NONE, UL &PostIndentString, UL "" },
/*
** .pp
- ** Similar to the $$attribution variable, Mutt will append this
+ ** Similar to the $$attribution variable, NeoMutt will append this
** string after the inclusion of a message which is being replied to.
*/
{ "post_indent_str", DT_SYNONYM, R_NONE, UL "post_indent_string", 0 },
{ "post_moderated", DT_QUAD, R_NONE, OPT_POST_MODERATED, MUTT_ASKYES },
/*
** .pp
- ** If set to \fIyes\fP, Mutt will post article to newsgroup that have
+ ** If set to \fIyes\fP, NeoMutt will post article to newsgroup that have
** not permissions to posting (e.g. moderated). \fBNote:\fP if news server
** does not support posting to that newsgroup or totally read-only, that
** posting will not have an effect.
{ "postponed", DT_PATH, R_INDEX, UL &Postponed, UL "~/postponed" },
/*
** .pp
- ** Mutt allows you to indefinitely ``$postpone sending a message'' which
- ** you are editing. When you choose to postpone a message, Mutt saves it
+ ** NeoMutt allows you to indefinitely ``$postpone sending a message'' which
+ ** you are editing. When you choose to postpone a message, NeoMutt saves it
** in the mailbox specified by this variable.
** .pp
** Also see the $$postpone variable.
/*
** .pp
** When \fIset\fP, postponed messages that are marked for encryption will be
- ** self-encrypted. Mutt will first try to encrypt using the value specified
+ ** self-encrypted. NeoMutt will first try to encrypt using the value specified
** in $$pgp_self_encrypt_as or $$smime_self_encrypt_as. If those are not
** set, it will try the deprecated $$postpone_encrypt_as.
** (Crypto only)
{ "preconnect", DT_STRING, R_NONE, UL &Preconnect, UL 0 },
/*
** .pp
- ** If \fIset\fP, a shell command to be executed if mutt fails to establish
+ ** If \fIset\fP, a shell command to be executed if NeoMutt fails to establish
** a connection to the server. This is useful for setting up secure
** connections, e.g. with \fCssh(1)\fP. If the command returns a nonzero
- ** status, mutt gives up opening the server. Example:
+ ** status, NeoMutt gives up opening the server. Example:
** .ts
** set preconnect="ssh -f -q -L 1234:mailhost.net:143 mailhost.net \(rs
** sleep 20 < /dev/null > /dev/null"
{ "print", DT_QUAD, R_NONE, OPT_PRINT, MUTT_ASKNO },
/*
** .pp
- ** Controls whether or not Mutt really prints messages.
+ ** Controls whether or not NeoMutt really prints messages.
** This is set to ``ask-no'' by default, because some people
** accidentally hit ``p'' often.
*/
/*
** .pp
** If you use an \fIexternal\fP $$pager, setting this variable will
- ** cause Mutt to prompt you for a command when the pager exits rather
- ** than returning to the index menu. If \fIunset\fP, Mutt will return to the
+ ** cause NeoMutt to prompt you for a command when the pager exits rather
+ ** than returning to the index menu. If \fIunset\fP, NeoMutt will return to the
** index menu when the external pager exits.
*/
{ "query_command", DT_PATH, R_NONE, UL &QueryCommand, UL "" },
/*
** .pp
- ** This specifies the command Mutt will use to make external address
+ ** This specifies the command NeoMutt will use to make external address
** queries. The string may contain a ``%s'', which will be substituted
- ** with the query string the user types. Mutt will add quotes around the
+ ** with the query string the user types. NeoMutt will add quotes around the
** string substituted for ``%s'' automatically according to shell quoting
** rules, so you should avoid adding your own. If no ``%s'' is found in
- ** the string, Mutt will append the user's query to the end of the string.
+ ** the string, NeoMutt will append the user's query to the end of the string.
** See ``$query'' for more information.
*/
{ "query_format", DT_STRING, R_NONE, UL &QueryFormat, UL "%4c %t %-25.25a %-25.25n %?e?(%e)?" },
/*
** .pp
** This variable controls whether ``quit'' and ``exit'' actually quit
- ** from mutt. If this option is \fIset\fP, they do quit, if it is \fIunset\fP, they
+ ** from NeoMutt. If this option is \fIset\fP, they do quit, if it is \fIunset\fP, they
** have no effect, and if it is set to \fIask-yes\fP or \fIask-no\fP, you are
** prompted for confirmation when you try to quit.
*/
{ "read_inc", DT_NUMBER, R_NONE, UL &ReadInc, 10 },
/*
** .pp
- ** If set to a value greater than 0, Mutt will display which message it
+ ** If set to a value greater than 0, NeoMutt will display which message it
** is currently on when reading a mailbox or when performing search actions
** such as search and limit. The message is printed after
- ** this many messages have been read or searched (e.g., if set to 25, Mutt will
+ ** this many messages have been read or searched (e.g., if set to 25, NeoMutt will
** print a message when it is at message 25, and then again when it gets
** to message 50). This variable is meant to indicate progress when
** reading or searching large mailboxes which may take some time.
{ "recall", DT_QUAD, R_NONE, OPT_RECALL, MUTT_ASKYES },
/*
** .pp
- ** Controls whether or not Mutt recalls postponed messages
+ ** Controls whether or not NeoMutt recalls postponed messages
** when composing a new message.
** .pp
** Setting this variable to \fIyes\fP is not generally useful, and thus not
{ "reflow_text", DT_BOOL, R_NONE, OPT_REFLOW_TEXT, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will reformat paragraphs in text/plain
- ** parts marked format=flowed. If \fIunset\fP, Mutt will display paragraphs
+ ** When \fIset\fP, NeoMutt will reformat paragraphs in text/plain
+ ** parts marked format=flowed. If \fIunset\fP, NeoMutt will display paragraphs
** unaltered from how they appear in the message body. See RFC3676 for
** details on the \fIformat=flowed\fP format.
** .pp
{ "reply_self", DT_BOOL, R_NONE, OPT_REPLY_SELF, 0 },
/*
** .pp
- ** If \fIunset\fP and you are replying to a message sent by you, Mutt will
+ ** If \fIunset\fP and you are replying to a message sent by you, NeoMutt will
** assume that you want to reply to the recipients of that message rather
** than to yourself.
** .pp
{ "reply_to", DT_QUAD, R_NONE, OPT_REPLY_TO, MUTT_ASKYES },
/*
** .pp
- ** If \fIset\fP, when replying to a message, Mutt will use the address listed
+ ** If \fIset\fP, when replying to a message, NeoMutt will use the address listed
** in the Reply-to: header as the recipient of the reply. If \fIunset\fP,
** it will use the address in the From: header field instead. This
** option is useful for reading a mailing list that sets the Reply-To:
** the command line) will have $$resume_draft_files automatically
** set when they are used as a draft file again.
** .pp
- ** The first time a draft file is saved, mutt will add a header,
+ ** The first time a draft file is saved, NeoMutt will add a header,
** X-Mutt-Resume-Draft to the saved file. The next time the draft
- ** file is read in, if mutt sees the header, it will set
+ ** file is read in, if NeoMutt sees the header, it will set
** $$resume_draft_files.
** .pp
** This option is designed to prevent multiple signatures,
{ "reverse_alias", DT_BOOL, R_BOTH, OPT_REVERSE_ALIAS, 0 },
/*
** .pp
- ** This variable controls whether or not Mutt will display the ``personal''
+ ** This variable controls whether or not NeoMutt will display the ``personal''
** name from your aliases in the index menu if it finds an alias that
** matches the message's sender. For example, if you have the following
** alias:
/*
** .pp
** This variable fine-tunes the behavior of the $$reverse_name feature.
- ** When it is \fIset\fP, mutt will use the address from incoming messages as-is,
- ** possibly including eventual real names. When it is \fIunset\fP, mutt will
+ ** When it is \fIset\fP, NeoMutt will use the address from incoming messages as-is,
+ ** possibly including eventual real names. When it is \fIunset\fP, NeoMutt will
** override any such real names with the setting of the $$realname variable.
*/
{ "rfc2047_parameters", DT_BOOL, R_NONE, OPT_RFC2047_PARAMETERS, 0 },
/*
** .pp
- ** When this variable is \fIset\fP, Mutt will decode RFC2047-encoded MIME
- ** parameters. You want to set this variable when mutt suggests you
+ ** When this variable is \fIset\fP, NeoMutt will decode RFC2047-encoded MIME
+ ** parameters. You want to set this variable when NeoMutt suggests you
** to save attachments to files named like:
** .ts
** =?iso-8859-1?Q?file=5F=E4=5F991116=2Ezip?=
** wild.
** .pp
** Also note that setting this parameter will \fInot\fP have the effect
- ** that mutt \fIgenerates\fP this kind of encoding. Instead, mutt will
+ ** that NeoMutt \fIgenerates\fP this kind of encoding. Instead, NeoMutt will
** unconditionally use the encoding specified in RFC2231.
*/
{ "save_address", DT_BOOL, R_NONE, OPT_SAVE_ADDRESS, 0 },
/*
** .pp
- ** If \fIset\fP, mutt will take the sender's full address when choosing a
+ ** If \fIset\fP, NeoMutt will take the sender's full address when choosing a
** default folder for saving a mail. If $$save_name or $$force_name
** is \fIset\fP too, the selection of the Fcc folder will be changed as well.
*/
** when closed (the exception is $$spoolfile which is never removed).
** If \fIset\fP, mailboxes are never removed.
** .pp
- ** \fBNote:\fP This only applies to mbox and MMDF folders, Mutt does not
+ ** \fBNote:\fP This only applies to mbox and MMDF folders, NeoMutt does not
** delete MH and Maildir directories.
*/
{ "save_history", DT_NUMBER, R_NONE, UL &SaveHistory, 0 },
/*
** .pp
** Messages which have been assigned a score equal to or lower than the value
- ** of this variable are automatically marked for deletion by mutt. Since
- ** mutt scores are always greater than or equal to zero, the default setting
+ ** of this variable are automatically marked for deletion by NeoMutt. Since
+ ** NeoMutt scores are always greater than or equal to zero, the default setting
** of this variable will never mark a message for deletion.
*/
{ "score_threshold_flag", DT_NUMBER, R_NONE, UL &ScoreThresholdFlag, 9999 },
/*
** .pp
** Messages which have been assigned a score equal to or lower than the value
- ** of this variable are automatically marked as read by mutt. Since
- ** mutt scores are always greater than or equal to zero, the default setting
+ ** of this variable are automatically marked as read by NeoMutt. Since
+ ** NeoMutt scores are always greater than or equal to zero, the default setting
** of this variable will never mark a message read.
*/
{ "search_context", DT_NUMBER, R_NONE, UL &SearchContext, UL 0 },
{ "send_charset", DT_STRING, R_NONE, UL &SendCharset, UL "us-ascii:iso-8859-1:utf-8" },
/*
** .pp
- ** A colon-delimited list of character sets for outgoing messages. Mutt will use the
+ ** A colon-delimited list of character sets for outgoing messages. NeoMutt will use the
** first character set into which the text can be converted exactly.
** If your $$charset is not ``iso-8859-1'' and recipients may not
** understand ``UTF-8'', it is advisable to include in the list an
** ``iso-8859-1''.
** .pp
** In case the text cannot be converted into one of these exactly,
- ** mutt uses $$charset as a fallback.
+ ** NeoMutt uses $$charset as a fallback.
*/
{ "sendmail", DT_PATH, R_NONE, UL &Sendmail, UL SENDMAIL " -oem -oi" },
/*
** .pp
- ** Specifies the program and arguments used to deliver mail sent by Mutt.
- ** Mutt expects that the specified program interprets additional
- ** arguments as recipient addresses. Mutt appends all recipients after
+ ** Specifies the program and arguments used to deliver mail sent by NeoMutt.
+ ** NeoMutt expects that the specified program interprets additional
+ ** arguments as recipient addresses. NeoMutt appends all recipients after
** adding a \fC--\fP delimiter (if not already present). Additional
** flags, such as for $$use_8bitmime, $$use_envelope_from,
** $$dsn_notify, or $$dsn_return will be added before the delimiter.
** Specifies the number of seconds to wait for the $$sendmail process
** to finish before giving up and putting delivery in the background.
** .pp
- ** Mutt interprets the value of this variable as follows:
+ ** NeoMutt interprets the value of this variable as follows:
** .dl
** .dt >0 .dd number of seconds to wait for sendmail to finish before continuing
** .dt 0 .dd wait forever for sendmail to finish
/*
** .pp
** This specifies the characters to be drawn between the sidebar (when
- ** visible) and the other Mutt panels. ASCII and Unicode line-drawing
+ ** visible) and the other NeoMutt panels. ASCII and Unicode line-drawing
** characters are supported.
*/
{ "sidebar_folder_indent", DT_BOOL, R_SIDEBAR, OPT_SIDEBAR_FOLDER_INDENT, 0 },
** $$signature. It is \fBstrongly\fP recommended that you not \fIunset\fP
** this variable unless your signature contains just your name. The
** reason for this is because many software packages use ``-- \n'' to
- ** detect your signature. For example, Mutt has the ability to highlight
+ ** detect your signature. For example, NeoMutt has the ability to highlight
** the signature in a different color in the built-in pager.
*/
{ "sig_on_top", DT_BOOL, R_NONE, OPT_SIG_ON_TOP, 0 },
{ "simple_search", DT_STRING, R_NONE, UL &SimpleSearch, UL "~f %s | ~s %s" },
/*
** .pp
- ** Specifies how Mutt should expand a simple search into a real search
+ ** Specifies how NeoMutt should expand a simple search into a real search
** pattern. A simple search is one that does not contain any of the ``~'' pattern
** operators. See ``$patterns'' for more information on search patterns.
** .pp
- ** For example, if you simply type ``joe'' at a search or limit prompt, Mutt
+ ** For example, if you simply type ``joe'' at a search or limit prompt, NeoMutt
** will automatically expand it to the value specified by this variable by
** replacing ``%s'' with the supplied string.
** For the default value, ``joe'' would be expanded to: ``~f joe | ~s joe''.
{ "smime_certificates", DT_PATH, R_NONE, UL &SmimeCertificates, 0 },
/*
** .pp
- ** Since for S/MIME there is no pubring/secring as with PGP, mutt has to handle
+ ** Since for S/MIME there is no pubring/secring as with PGP, NeoMutt has to handle
** storage and retrieval of keys by itself. This is very basic right
** now, and keys and certificates are stored in two different
** directories, both named as the hash-value retrieved from
{ "smime_decrypt_use_default_key", DT_BOOL, R_NONE, OPT_SMIME_DECRYPT_USE_DEFAULT_KEY, 1 },
/*
** .pp
- ** If \fIset\fP (default) this tells mutt to use the default key for decryption. Otherwise,
- ** if managing multiple certificate-key-pairs, mutt will try to use the mailbox-address
+ ** If \fIset\fP (default) this tells NeoMutt to use the default key for decryption. Otherwise,
+ ** if managing multiple certificate-key-pairs, NeoMutt will try to use the mailbox-address
** to determine the key to use. It will ask you to supply a key, if it can't find one.
** (S/MIME only)
*/
{ "smime_is_default", DT_BOOL, R_NONE, OPT_SMIME_IS_DEFAULT, 0 },
/*
** .pp
- ** The default behavior of mutt is to use PGP on all auto-sign/encryption
+ ** The default behavior of NeoMutt is to use PGP on all auto-sign/encryption
** operations. To override and to use OpenSSL instead this must be \fIset\fP.
- ** However, this has no effect while replying, since mutt will automatically
+ ** However, this has no effect while replying, since NeoMutt will automatically
** select the same application that was used to sign/encrypt the original
** message. (Note that this variable can be overridden by unsetting $$crypt_autosmime.)
** (S/MIME only)
{ "smime_keys", DT_PATH, R_NONE, UL &SmimeKeys, 0 },
/*
** .pp
- ** Since for S/MIME there is no pubring/secring as with PGP, mutt has to handle
+ ** Since for S/MIME there is no pubring/secring as with PGP, NeoMutt has to handle
** storage and retrieval of keys/certs by itself. This is very basic right now,
** and stores keys and certificates in two different directories, both
** named as the hash-value retrieved from OpenSSL. There is an index file
{ "smtp_authenticators", DT_STRING, R_NONE, UL &SmtpAuthenticators, UL 0 },
/*
** .pp
- ** This is a colon-delimited list of authentication methods mutt may
- ** attempt to use to log in to an SMTP server, in the order mutt should
+ ** This is a colon-delimited list of authentication methods NeoMutt may
+ ** attempt to use to log in to an SMTP server, in the order NeoMutt should
** try them. Authentication methods are any SASL mechanism, e.g. ``plain'',
** ``digest-md5'', ``gssapi'' or ``cram-md5''.
** This option is case-insensitive. If it is ``unset''
- ** (the default) mutt will try all available methods, in order from
+ ** (the default) NeoMutt will try all available methods, in order from
** most-secure to least-secure. Support for the ``plain'' mechanism is
** bundled; other mechanisms are provided by an external SASL library (look
- ** for +USE_SASL in the output of mutt -v).
+ ** for +USE_SASL in the output of neomutt -v).
** .pp
** Example:
** .ts
{ "smtp_pass", DT_STRING, R_NONE|F_SENSITIVE, UL &SmtpPass, UL 0 },
/*
** .pp
- ** Specifies the password for your SMTP account. If \fIunset\fP, Mutt will
+ ** Specifies the password for your SMTP account. If \fIunset\fP, NeoMutt will
** prompt you for your password when you first send mail via SMTP.
- ** See $$smtp_url to configure mutt to send mail via SMTP.
+ ** See $$smtp_url to configure NeoMutt to send mail via SMTP.
** .pp
** \fBWarning\fP: you should only use this option when you are on a
** fairly secure machine, because the superuser can read your muttrc even
** When sorting by threads, this variable controls how threads are sorted
** in relation to other threads, and how the branches of the thread trees
** are sorted. This can be set to any value that $$sort can, except
- ** ``threads'' (in that case, mutt will just use ``date-sent''). You can also
+ ** ``threads'' (in that case, NeoMutt will just use ``date-sent''). You can also
** specify the ``last-'' prefix in addition to the ``reverse-'' prefix, but ``last-''
** must come after ``reverse-''. The ``last-'' prefix causes messages to be
** sorted against its siblings by which has the last descendant, using
{ "spoolfile", DT_PATH, R_NONE, UL &SpoolFile, 0 },
/*
** .pp
- ** If your spool mailbox is in a non-default place where Mutt cannot find
- ** it, you can specify its location with this variable. Mutt will
+ ** If your spool mailbox is in a non-default place where NeoMutt cannot find
+ ** it, you can specify its location with this variable. NeoMutt will
** initially set this variable to the value of the environment
** variable \fC$$$MAIL\fP or \fC$$$MAILDIR\fP if either is defined.
*/
{ "ssl_force_tls", DT_BOOL, R_NONE, OPT_SSL_FORCE_TLS, 0 },
/*
** .pp
- ** If this variable is \fIset\fP, Mutt will require that all connections
+ ** If this variable is \fIset\fP, NeoMutt will require that all connections
** to remote servers be encrypted. Furthermore it will attempt to
** negotiate TLS even if the server does not advertise the capability,
** since it would otherwise have to abort the connection anyway. This
{ "ssl_starttls", DT_QUAD, R_NONE, OPT_SSL_STARTTLS, MUTT_YES },
/*
** .pp
- ** If \fIset\fP (the default), mutt will attempt to use \fCSTARTTLS\fP on servers
- ** advertising the capability. When \fIunset\fP, mutt will not attempt to
+ ** If \fIset\fP (the default), NeoMutt will attempt to use \fCSTARTTLS\fP on servers
+ ** advertising the capability. When \fIunset\fP, NeoMutt will not attempt to
** use \fCSTARTTLS\fP regardless of the server's capabilities.
*/
#ifdef USE_SSL_OPENSSL
{ "ssl_usesystemcerts", DT_BOOL, R_NONE, OPT_SSL_USESYSTEMCERTS, 1 },
/*
** .pp
- ** If set to \fIyes\fP, mutt will use CA certificates in the
+ ** If set to \fIyes\fP, NeoMutt will use CA certificates in the
** system-wide certificate store when checking if a server certificate
** is signed by a trusted CA.
*/
{ "ssl_verify_dates", DT_BOOL, R_NONE, OPT_SSL_VERIFY_DATES, 1 },
/*
** .pp
- ** If \fIset\fP (the default), mutt will not automatically accept a server
+ ** If \fIset\fP (the default), NeoMutt will not automatically accept a server
** certificate that is either not yet valid or already expired. You should
** only unset this for particular known hosts, using the
** \fC$<account-hook>\fP function.
{ "ssl_verify_host", DT_BOOL, R_NONE, OPT_SSL_VERIFY_HOST, 1 },
/*
** .pp
- ** If \fIset\fP (the default), mutt will not automatically accept a server
+ ** If \fIset\fP (the default), NeoMutt will not automatically accept a server
** certificate whose host name does not match the host used in your folder
** URL. You should only unset this for particular known hosts, using
** the \fC$<account-hook>\fP function.
** .dt %S .dd current aux sorting method ($$sort_aux)
** .dt %t .dd number of tagged messages *
** .dt %u .dd number of unread messages *
- ** .dt %v .dd Mutt version string
+ ** .dt %v .dd NeoMutt version string
** .dt %V .dd currently active limit pattern, if any *
** .dt %>X .dd right justify the rest of the string and pad with ``X''
** .dt %|X .dd pad to the end of the line with ``X''
** For example, if you want to display the local hostname in lowercase,
** you would use: ``\fC%_h\fP''.
** .pp
- ** If you prefix the sequence character with a colon (``:'') character, mutt
+ ** If you prefix the sequence character with a colon (``:'') character, NeoMutt
** will replace any dots in the expansion by underscores. This might be helpful
** with IMAP folders that don't like dots in folder names.
*/
{ "suspend", DT_BOOL, R_NONE, OPT_SUSPEND, 1 },
/*
** .pp
- ** When \fIunset\fP, mutt won't stop when the user presses the terminal's
- ** \fIsusp\fP key, usually ``^Z''. This is useful if you run mutt
+ ** When \fIunset\fP, NeoMutt won't stop when the user presses the terminal's
+ ** \fIsusp\fP key, usually ``^Z''. This is useful if you run NeoMutt
** inside an xterm using a command like ``\fCxterm -e mutt\fP''.
*/
{ "text_flowed", DT_BOOL, R_NONE, OPT_TEXT_FLOWED, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will generate ``format=flowed'' bodies with a content type
+ ** When \fIset\fP, NeoMutt will generate ``format=flowed'' bodies with a content type
** of ``\fCtext/plain; format=flowed\fP''.
** This format is easier to handle for some mailing software, and generally
** just looks like ordinary text. To actually make use of this format's
** .pp
** Users searching attachments or for non-ASCII characters should \fIset\fP
** this value because decoding also includes MIME parsing/decoding and possible
- ** character set conversions. Otherwise mutt will attempt to match against the
+ ** character set conversions. Otherwise NeoMutt will attempt to match against the
** raw message received (for example quoted-printable encoded or with encoded
** headers) which may lead to incorrect search results.
*/
{ "thread_received", DT_BOOL, R_RESORT|R_RESORT_INIT|R_INDEX, OPT_THREAD_RECEIVED, 0 },
/*
** .pp
- ** When \fIset\fP, mutt uses the date received rather than the date sent
+ ** When \fIset\fP, NeoMutt uses the date received rather than the date sent
** to thread messages by subject.
*/
{ "tilde", DT_BOOL, R_PAGER, OPT_TILDE, 0 },
** variable controls the frequency with which progress updates are
** displayed. It suppresses updates less than $$time_inc milliseconds
** apart. This can improve throughput on systems with slow terminals,
- ** or when running mutt on a remote system.
+ ** or when running NeoMutt on a remote system.
** .pp
** Also see the ``$tuning'' section of the manual for performance considerations.
*/
{ "timeout", DT_NUMBER, R_NONE, UL &Timeout, 600 },
/*
** .pp
- ** When Mutt is waiting for user input either idling in menus or
- ** in an interactive prompt, Mutt would block until input is
+ ** When NeoMutt is waiting for user input either idling in menus or
+ ** in an interactive prompt, NeoMutt would block until input is
** present. Depending on the context, this would prevent certain
** operations from working, like checking for new mail or keeping
** an IMAP connection alive.
** .pp
- ** This variable controls how many seconds Mutt will at most wait
+ ** This variable controls how many seconds NeoMutt will at most wait
** until it aborts waiting for input, performs these operations and
** continues to wait for input.
** .pp
- ** A value of zero or less will cause Mutt to never time out.
+ ** A value of zero or less will cause NeoMutt to never time out.
*/
{ "tmpdir", DT_PATH, R_NONE, UL &Tmpdir, 0 },
/*
** .pp
- ** This variable allows you to specify where Mutt will place its
+ ** This variable allows you to specify where NeoMutt will place its
** temporary files needed for displaying and composing messages. If
** this variable is not set, the environment variable \fC$$$TMPDIR\fP is
** used. If \fC$$$TMPDIR\fP is not set then ``\fC/tmp\fP'' is used.
/* The default must be off to force in the validity checking. */
/*
** .pp
- ** Controls whether mutt tries to set the terminal status line and icon name.
+ ** Controls whether NeoMutt tries to set the terminal status line and icon name.
** Most terminal emulators emulate the status line in the window title.
*/
{ "ts_status_format", DT_STRING, R_BOTH, UL &TSStatusFormat, UL "NeoMutt with %?m?%m messages&no messages?%?n? [%n NEW]?" },
{ "tunnel", DT_STRING, R_NONE, UL &Tunnel, UL 0 },
/*
** .pp
- ** Setting this variable will cause mutt to open a pipe to a command
+ ** Setting this variable will cause NeoMutt to open a pipe to a command
** instead of a raw socket. You may be able to use this to set up
** preauthenticated connections to your IMAP/POP3/SMTP server. Example:
** .ts
** Note: For this example to work you must be able to log in to the remote
** machine without having to enter a password.
** .pp
- ** When set, Mutt uses the tunnel for all remote connections.
+ ** When set, NeoMutt uses the tunnel for all remote connections.
** Please see ``$account-hook'' in the manual for how to use different
** tunnel commands per connection.
*/
{ "uncollapse_jump", DT_BOOL, R_NONE, OPT_UNCOLLAPSE_JUMP, 0 },
/*
** .pp
- ** When \fIset\fP, Mutt will jump to the next unread message, if any,
+ ** When \fIset\fP, NeoMutt will jump to the next unread message, if any,
** when the current thread is \fIun\fPcollapsed.
*/
{ "uncollapse_new", DT_BOOL, R_NONE, OPT_UNCOLLAPSE_NEW, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will automatically uncollapse any collapsed thread
+ ** When \fIset\fP, NeoMutt will automatically uncollapse any collapsed thread
** that receives a new message. When \fIunset\fP, collapsed threads will
** remain collapsed. the presence of the new message will still affect
** index sorting, though.
** of sendmail which supports the \fC-B8BITMIME\fP flag (such as sendmail
** 8.8.x) or you may not be able to send mail.
** .pp
- ** When \fIset\fP, Mutt will invoke $$sendmail with the \fC-B8BITMIME\fP
+ ** When \fIset\fP, NeoMutt will invoke $$sendmail with the \fC-B8BITMIME\fP
** flag when sending 8-bit messages to enable ESMTP negotiation.
*/
{ "use_domain", DT_BOOL, R_NONE, OPT_USE_DOMAIN, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will qualify all local addresses (ones without the
+ ** When \fIset\fP, NeoMutt will qualify all local addresses (ones without the
** ``@host'' portion) with the value of $$hostname. If \fIunset\fP, no
** addresses will be qualified.
*/
{ "use_envelope_from", DT_BOOL, R_NONE, OPT_USE_ENVELOPE_FROM, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will set the \fIenvelope\fP sender of the message.
+ ** When \fIset\fP, NeoMutt will set the \fIenvelope\fP sender of the message.
** If $$envelope_from_address is \fIset\fP, it will be used as the sender
- ** address. If \fIunset\fP, mutt will attempt to derive the sender from the
+ ** address. If \fIunset\fP, NeoMutt will attempt to derive the sender from the
** ``From:'' header.
** .pp
** Note that this information is passed to sendmail command using the
{ "use_from", DT_BOOL, R_NONE, OPT_USE_FROM, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will generate the ``From:'' header field when
+ ** When \fIset\fP, NeoMutt will generate the ``From:'' header field when
** sending messages. If \fIunset\fP, no ``From:'' header field will be
** generated unless the user explicitly sets one using the ``$my_hdr''
** command.
{ "use_ipv6", DT_BOOL, R_NONE, OPT_USE_IPV6, 1 },
/*
** .pp
- ** When \fIset\fP, Mutt will look for IPv6 addresses of hosts it tries to
- ** contact. If this option is \fIunset\fP, Mutt will restrict itself to IPv4 addresses.
+ ** When \fIset\fP, NeoMutt will look for IPv6 addresses of hosts it tries to
+ ** contact. If this option is \fIunset\fP, NeoMutt will restrict itself to IPv4 addresses.
** Normally, the default should work.
*/
#endif /* HAVE_GETADDRINFO */
{ "user_agent", DT_BOOL, R_NONE, OPT_USER_AGENT, 1 },
/*
** .pp
- ** When \fIset\fP, mutt will add a ``User-Agent:'' header to outgoing
- ** messages, indicating which version of mutt was used for composing
+ ** When \fIset\fP, NeoMutt will add a ``User-Agent:'' header to outgoing
+ ** messages, indicating which version of NeoMutt was used for composing
** them.
*/
{ "visual", DT_PATH, R_NONE, UL &Visual, 0 },
{ "virtual_spoolfile", DT_BOOL, R_NONE, OPT_VIRTUAL_SPOOLFILE, 0 },
/*
** .pp
- ** When \fIset\fP, mutt will use the first defined virtual mailbox (see
+ ** When \fIset\fP, NeoMutt will use the first defined virtual mailbox (see
** virtual-mailboxes) as a spool file.
*/
#endif
{ "wait_key", DT_BOOL, R_NONE, OPT_WAIT_KEY, 1 },
/*
** .pp
- ** Controls whether Mutt will ask you to press a key after an external command
+ ** Controls whether NeoMutt will ask you to press a key after an external command
** has been invoked by these functions: \fC<shell-escape>\fP,
** \fC<pipe-message>\fP, \fC<pipe-entry>\fP, \fC<print-message>\fP,
** and \fC<print-entry>\fP commands.
** that the corresponding mailcap entry has a \fIneedsterminal\fP flag,
** and the external program is interactive.
** .pp
- ** When \fIset\fP, Mutt will always ask for a key. When \fIunset\fP, Mutt will wait
+ ** When \fIset\fP, NeoMutt will always ask for a key. When \fIunset\fP, NeoMutt will wait
** for a key only if the external command returned a non-zero status.
*/
{ "weed", DT_BOOL, R_NONE, OPT_WEED, 1 },
/*
** .pp
- ** When \fIset\fP, mutt will weed headers when displaying, forwarding,
+ ** When \fIset\fP, NeoMutt will weed headers when displaying, forwarding,
** printing, or replying to messages.
*/
{ "wrap", DT_NUMBER, R_PAGER, UL &Wrap, 0 },
/*
** .pp
- ** When set to a positive value, mutt will wrap text at $$wrap characters.
- ** When set to a negative value, mutt will wrap text so that there are $$wrap
+ ** When set to a positive value, NeoMutt will wrap text at $$wrap characters.
+ ** When set to a negative value, NeoMutt will wrap text so that there are $$wrap
** characters of empty space on the right side of the terminal. Setting it
- ** to zero makes mutt wrap at the terminal width.
+ ** to zero makes NeoMutt wrap at the terminal width.
** .pp
** Also see $$reflow_wrap.
*/
{ "write_bcc", DT_BOOL, R_NONE, OPT_WRITE_BCC, 1 },
/*
** .pp
- ** Controls whether mutt writes out the ``Bcc:'' header when preparing
- ** messages to be sent. Exim users may wish to unset this. If mutt
+ ** Controls whether NeoMutt writes out the ``Bcc:'' header when preparing
+ ** messages to be sent. Exim users may wish to unset this. If NeoMutt
** is set to deliver directly via SMTP (see $$smtp_url), this
- ** option does nothing: mutt will never write out the ``Bcc:'' header
+ ** option does nothing: NeoMutt will never write out the ``Bcc:'' header
** in this case.
*/
{ "write_inc", DT_NUMBER, R_NONE, UL &WriteInc, 10 },
/*
** .pp
** The character used to delimit distinct keywords in X-Label headers.
- ** X-Label is primarily a Mutt artifact, and the semantics of the field
+ ** X-Label is primarily a NeoMutt artifact, and the semantics of the field
** were never defined: it is free-form text. However interaction with
** X-Keywords:, X-Mozilla-Keys:, and Keywords: requires that we adopt
** some means of identifying separate keywords within the field. Set
{ "x_comment_to", DT_BOOL, R_NONE, OPT_X_COMMENT_TO, 0 },
/*
** .pp
- ** If \fIset\fP, Mutt will add ``X-Comment-To:'' field (that contains full
+ ** If \fIset\fP, NeoMutt will add ``X-Comment-To:'' field (that contains full
** name of original article author) to article that followuped to newsgroup.
*/
#endif
{ "collapse_all", DT_BOOL, R_NONE, OPT_COLLAPSE_ALL, 0 },
/*
** .pp
- ** When \fIset\fP, Mutt will collapse all threads when entering a folder.
+ ** When \fIset\fP, NeoMutt will collapse all threads when entering a folder.
*/
/*--*/
{ "pgp_encrypt_self", DT_QUAD, R_NONE, OPT_PGP_ENCRYPT_SELF, MUTT_NO },
projects / neomutt / commitdiff