33#include "docs/makedoc_defs.h"
91 {
"alias-dialog", OP_ALIAS_DIALOG },
93 {
"autocrypt-acct-menu", OP_AUTOCRYPT_ACCT_MENU },
95 {
"bounce-message", OP_BOUNCE_MESSAGE },
96 {
"break-thread", OP_MAIN_BREAK_THREAD },
97 {
"catchup", OP_CATCHUP },
98 {
"change-folder", OP_MAIN_CHANGE_FOLDER },
99 {
"change-folder-readonly", OP_MAIN_CHANGE_FOLDER_READONLY },
100 {
"change-newsgroup", OP_MAIN_CHANGE_GROUP },
101 {
"change-newsgroup-readonly", OP_MAIN_CHANGE_GROUP_READONLY },
103 {
"change-vfolder", OP_MAIN_CHANGE_VFOLDER },
105 {
"check-traditional-pgp", OP_CHECK_TRADITIONAL },
106 {
"clear-flag", OP_MAIN_CLEAR_FLAG },
107 {
"collapse-all", OP_MAIN_COLLAPSE_ALL },
108 {
"collapse-thread", OP_MAIN_COLLAPSE_THREAD },
109 {
"compose-to-sender", OP_COMPOSE_TO_SENDER },
110 {
"copy-message", OP_COPY_MESSAGE },
111 {
"create-alias", OP_CREATE_ALIAS },
112 {
"decode-copy", OP_DECODE_COPY },
113 {
"decode-save", OP_DECODE_SAVE },
114 {
"decrypt-copy", OP_DECRYPT_COPY },
115 {
"decrypt-save", OP_DECRYPT_SAVE },
116 {
"delete-message", OP_DELETE },
117 {
"delete-pattern", OP_MAIN_DELETE_PATTERN },
118 {
"delete-subthread", OP_DELETE_SUBTHREAD },
119 {
"delete-thread", OP_DELETE_THREAD },
120 {
"display-address", OP_DISPLAY_ADDRESS },
121 {
"display-message", OP_DISPLAY_MESSAGE },
122 {
"display-toggle-weed", OP_DISPLAY_HEADERS },
123 {
"edit", OP_EDIT_RAW_MESSAGE },
124 {
"edit-label", OP_EDIT_LABEL },
125 {
"edit-or-view-raw-message", OP_EDIT_OR_VIEW_RAW_MESSAGE },
126 {
"edit-raw-message", OP_EDIT_RAW_MESSAGE },
127 {
"edit-type", OP_ATTACHMENT_EDIT_TYPE },
129 {
"entire-thread", OP_MAIN_ENTIRE_THREAD },
132 {
"extract-keys", OP_EXTRACT_KEYS },
133 {
"fetch-mail", OP_MAIN_FETCH_MAIL },
134 {
"flag-message", OP_FLAG_MESSAGE },
135 {
"followup-message", OP_FOLLOWUP },
136 {
"forget-passphrase", OP_FORGET_PASSPHRASE },
137 {
"forward-message", OP_FORWARD_MESSAGE },
138 {
"forward-to-group", OP_FORWARD_TO_GROUP },
139 {
"get-children", OP_GET_CHILDREN },
140 {
"get-message", OP_GET_MESSAGE },
141 {
"get-parent", OP_GET_PARENT },
142 {
"group-chat-reply", OP_GROUP_CHAT_REPLY },
143 {
"group-reply", OP_GROUP_REPLY },
144 {
"imap-fetch-mail", OP_MAIN_IMAP_FETCH },
145 {
"imap-logout-all", OP_MAIN_IMAP_LOGOUT_ALL },
146 {
"limit", OP_MAIN_LIMIT },
147 {
"limit-current-thread", OP_LIMIT_CURRENT_THREAD },
148 {
"link-threads", OP_MAIN_LINK_THREADS },
149 {
"list-reply", OP_LIST_REPLY },
150 {
"list-subscribe", OP_LIST_SUBSCRIBE },
151 {
"list-unsubscribe", OP_LIST_UNSUBSCRIBE },
153 {
"mail-key", OP_MAIL_KEY },
154 {
"mailbox-list", OP_MAILBOX_LIST },
155 {
"mark-message", OP_MARK_MSG },
156 {
"modify-labels", OP_MAIN_MODIFY_TAGS },
157 {
"modify-labels-then-hide", OP_MAIN_MODIFY_TAGS_THEN_HIDE },
158 {
"modify-tags", OP_MAIN_MODIFY_TAGS },
159 {
"modify-tags-then-hide", OP_MAIN_MODIFY_TAGS_THEN_HIDE },
160 {
"next-new", OP_MAIN_NEXT_NEW },
161 {
"next-new-then-unread", OP_MAIN_NEXT_NEW_THEN_UNREAD },
162 {
"next-subthread", OP_MAIN_NEXT_SUBTHREAD },
163 {
"next-thread", OP_MAIN_NEXT_THREAD },
164 {
"next-undeleted", OP_MAIN_NEXT_UNDELETED },
165 {
"next-unread", OP_MAIN_NEXT_UNREAD },
166 {
"next-unread-mailbox", OP_MAIN_NEXT_UNREAD_MAILBOX },
167 {
"parent-message", OP_MAIN_PARENT_MESSAGE },
168 {
"pipe-entry", OP_PIPE },
169 {
"pipe-message", OP_PIPE },
170 {
"post-message", OP_POST },
171 {
"previous-new", OP_MAIN_PREV_NEW },
172 {
"previous-new-then-unread", OP_MAIN_PREV_NEW_THEN_UNREAD },
173 {
"previous-subthread", OP_MAIN_PREV_SUBTHREAD },
174 {
"previous-thread", OP_MAIN_PREV_THREAD },
175 {
"previous-undeleted", OP_MAIN_PREV_UNDELETED },
176 {
"previous-unread", OP_MAIN_PREV_UNREAD },
177 {
"print-message", OP_PRINT },
178 {
"purge-message", OP_PURGE_MESSAGE },
179 {
"purge-thread", OP_PURGE_THREAD },
180 {
"quasi-delete", OP_MAIN_QUASI_DELETE },
181 {
"query", OP_QUERY },
183 {
"read-subthread", OP_MAIN_READ_SUBTHREAD },
184 {
"read-thread", OP_MAIN_READ_THREAD },
185 {
"recall-message", OP_RECALL_MESSAGE },
186 {
"reconstruct-thread", OP_RECONSTRUCT_THREAD },
187 {
"reply", OP_REPLY },
188 {
"resend-message", OP_RESEND },
189 {
"root-message", OP_MAIN_ROOT_MESSAGE },
190 {
"save-message", OP_SAVE },
191 {
"set-flag", OP_MAIN_SET_FLAG },
192 {
"show-limit", OP_MAIN_SHOW_LIMIT },
193 {
"sidebar-first", OP_SIDEBAR_FIRST },
194 {
"sidebar-last", OP_SIDEBAR_LAST },
195 {
"sidebar-next", OP_SIDEBAR_NEXT },
196 {
"sidebar-next-new", OP_SIDEBAR_NEXT_NEW },
197 {
"sidebar-open", OP_SIDEBAR_OPEN },
198 {
"sidebar-page-down", OP_SIDEBAR_PAGE_DOWN },
199 {
"sidebar-page-up", OP_SIDEBAR_PAGE_UP },
200 {
"sidebar-prev", OP_SIDEBAR_PREV },
201 {
"sidebar-prev-new", OP_SIDEBAR_PREV_NEW },
202 {
"sidebar-toggle-virtual", OP_SIDEBAR_TOGGLE_VIRTUAL },
203 {
"sidebar-toggle-visible", OP_SIDEBAR_TOGGLE_VISIBLE },
204 {
"sort-mailbox", OP_SORT },
205 {
"sort-reverse", OP_SORT_REVERSE },
206 {
"sync-mailbox", OP_MAIN_SYNC_FOLDER },
207 {
"tag-pattern", OP_MAIN_TAG_PATTERN },
208 {
"tag-subthread", OP_TAG_SUBTHREAD },
209 {
"tag-thread", OP_TAG_THREAD },
210 {
"toggle-new", OP_TOGGLE_NEW },
211 {
"toggle-read", OP_TOGGLE_READ },
212 {
"toggle-write", OP_TOGGLE_WRITE },
213 {
"undelete-message", OP_UNDELETE },
214 {
"undelete-pattern", OP_MAIN_UNDELETE_PATTERN },
215 {
"undelete-subthread", OP_UNDELETE_SUBTHREAD },
216 {
"undelete-thread", OP_UNDELETE_THREAD },
217 {
"untag-pattern", OP_MAIN_UNTAG_PATTERN },
219 {
"vfolder-from-query", OP_MAIN_VFOLDER_FROM_QUERY },
220 {
"vfolder-from-query-readonly", OP_MAIN_VFOLDER_FROM_QUERY_READONLY },
221 {
"vfolder-window-backward", OP_MAIN_WINDOWED_VFOLDER_BACKWARD },
222 {
"vfolder-window-forward", OP_MAIN_WINDOWED_VFOLDER_FORWARD },
223 {
"vfolder-window-reset", OP_MAIN_WINDOWED_VFOLDER_RESET },
225 {
"view-attachments", OP_VIEW_ATTACHMENTS },
226 {
"view-raw-message", OP_VIEW_RAW_MESSAGE },
228 {
"buffy-list", OP_MAILBOX_LIST },
236 { OP_ATTACHMENT_EDIT_TYPE,
"\005" },
238 { OP_AUTOCRYPT_ACCT_MENU,
"A" },
240 { OP_BOUNCE_MESSAGE,
"b" },
241 { OP_CHECK_TRADITIONAL,
"\033P" },
242 { OP_COPY_MESSAGE,
"C" },
243 { OP_CREATE_ALIAS,
"a" },
244 { OP_DECODE_COPY,
"\033C" },
245 { OP_DECODE_SAVE,
"\033s" },
247 { OP_DELETE_SUBTHREAD,
"\033d" },
248 { OP_DELETE_THREAD,
"\004" },
249 { OP_DISPLAY_ADDRESS,
"@" },
250 { OP_DISPLAY_HEADERS,
"h" },
251 { OP_DISPLAY_MESSAGE,
" " },
252 { OP_DISPLAY_MESSAGE,
"<keypadenter>" },
253 { OP_DISPLAY_MESSAGE,
"\n" },
254 { OP_DISPLAY_MESSAGE,
"\r" },
255 { OP_EDIT_LABEL,
"Y" },
256 { OP_EDIT_OR_VIEW_RAW_MESSAGE,
"e" },
258 { OP_EXTRACT_KEYS,
"\013" },
259 { OP_FLAG_MESSAGE,
"F" },
260 { OP_FORGET_PASSPHRASE,
"\006" },
261 { OP_FORWARD_MESSAGE,
"f" },
262 { OP_GROUP_REPLY,
"g" },
263 { OP_LIST_REPLY,
"L" },
265 { OP_MAILBOX_LIST,
"." },
266 { OP_MAIL_KEY,
"\033k" },
267 { OP_MAIN_BREAK_THREAD,
"#" },
268 { OP_MAIN_CHANGE_FOLDER,
"c" },
269 { OP_MAIN_CHANGE_FOLDER_READONLY,
"\033c" },
270 { OP_MAIN_CHANGE_GROUP,
"i" },
271 { OP_MAIN_CHANGE_GROUP_READONLY,
"\033i" },
272 { OP_MAIN_CLEAR_FLAG,
"W" },
273 { OP_MAIN_COLLAPSE_ALL,
"\033V" },
274 { OP_MAIN_COLLAPSE_THREAD,
"\033v" },
275 { OP_MAIN_DELETE_PATTERN,
"D" },
276 { OP_MAIN_FETCH_MAIL,
"G" },
277 { OP_MAIN_LIMIT,
"l" },
278 { OP_MAIN_LINK_THREADS,
"&" },
279 { OP_MAIN_NEXT_NEW_THEN_UNREAD,
"\t" },
280 { OP_MAIN_NEXT_SUBTHREAD,
"\033n" },
281 { OP_MAIN_NEXT_THREAD,
"\016" },
282 { OP_MAIN_NEXT_UNDELETED,
"<down>" },
283 { OP_MAIN_NEXT_UNDELETED,
"j" },
284 { OP_MAIN_PARENT_MESSAGE,
"P" },
285 { OP_MAIN_PREV_NEW_THEN_UNREAD,
"\033\t" },
286 { OP_MAIN_PREV_SUBTHREAD,
"\033p" },
287 { OP_MAIN_PREV_THREAD,
"\020" },
288 { OP_MAIN_PREV_UNDELETED,
"<up>" },
289 { OP_MAIN_PREV_UNDELETED,
"k" },
290 { OP_MAIN_READ_SUBTHREAD,
"\033r" },
291 { OP_MAIN_READ_THREAD,
"\022" },
292 { OP_MAIN_SET_FLAG,
"w" },
293 { OP_MAIN_SHOW_LIMIT,
"\033l" },
294 { OP_MAIN_SYNC_FOLDER,
"$" },
295 { OP_MAIN_TAG_PATTERN,
"T" },
296 { OP_MAIN_UNDELETE_PATTERN,
"U" },
297 { OP_MAIN_UNTAG_PATTERN,
"\024" },
298 { OP_MARK_MSG,
"~" },
299 { OP_NEXT_ENTRY,
"J" },
301 { OP_PREV_ENTRY,
"K" },
305 { OP_RECALL_MESSAGE,
"R" },
307 { OP_RESEND,
"\033e" },
309 { OP_SHOW_LOG_MESSAGES,
"M" },
311 { OP_SORT_REVERSE,
"O" },
312 { OP_TAG_THREAD,
"\033t" },
313 { OP_TOGGLE_NEW,
"N" },
314 { OP_TOGGLE_WRITE,
"%" },
315 { OP_UNDELETE,
"u" },
316 { OP_UNDELETE_SUBTHREAD,
"\033u" },
317 { OP_UNDELETE_THREAD,
"\025" },
318 { OP_VIEW_ATTACHMENTS,
"v" },
501 struct AddressList *al = NULL;
565 int subthread = (op == OP_DELETE_SUBTHREAD);
569 if (op == OP_PURGE_THREAD)
612 if (op == OP_DISPLAY_HEADERS)
627 if (c_uncollapse_jump)
632 if (c_pgp_auto_decode &&
686 mutt_message(ngettext(
"%d label changed",
"%d labels changed", num_changed), num_changed);
713 if (op == OP_EDIT_RAW_MESSAGE)
720 else if (op == OP_EDIT_OR_VIEW_RAW_MESSAGE)
732 if (c_pgp_auto_decode &&
809 for (
size_t i = 0; i < m->
msg_count; i++)
853 if (c_pgp_auto_decode &&
878 if (op == OP_GROUP_REPLY)
887 if (c_pgp_auto_decode &&
909 const int digit = op - OP_JUMP;
922 else if (!mutt_str_atoi_full(
buf_string(buf), &msg_num))
961 if (c_pgp_auto_decode &&
1064 mutt_error(
_(
"Thread can't be broken, message is not part of a thread"));
1087 if (shared->
attach_msg || c_read_only || (op == OP_MAIN_CHANGE_FOLDER_READONLY))
1089 cp =
_(
"Open mailbox in read-only mode");
1094 cp =
_(
"Open mailbox");
1098 const bool c_change_folder_next =
cs_subset_bool(shared->
sub,
"change_folder_next");
1110 goto changefoldercleanup;
1119 goto changefoldercleanup;
1175 if (c_uncollapse_jump)
1186 mutt_error(
_(
"Thread contains unread or flagged messages"));
1226 if (op == OP_TOGGLE_READ)
1228 char buf2[1024] = { 0 };
1238 snprintf(buf2,
sizeof(buf2),
"~A");
1244 if (((op == OP_LIMIT_CURRENT_THREAD) &&
1246 (op == OP_TOGGLE_READ) ||
1248 _(
"Limit to messages matching: ")) == 0)))
1260 if (e->
index == old_index)
1306 mutt_error(
_(
"No Message-ID: header available to link thread"));
1347 struct Buffer *buf = NULL;
1354 mutt_message(
_(
"Folder doesn't support tagging, aborting"));
1381 struct Progress *progress = NULL;
1393 for (
int px = 0, i = 0; i < m->
msg_count; i++)
1404 if (op == OP_MAIN_MODIFY_TAGS_THEN_HIDE)
1406 bool still_queried =
false;
1430 if (op == OP_MAIN_MODIFY_TAGS_THEN_HIDE)
1432 bool still_queried =
false;
1464 int first_unread = -1;
1468 int mcur = saved_current;
1473 if ((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_NEXT_UNREAD) ||
1474 (op == OP_MAIN_NEXT_NEW_THEN_UNREAD))
1497 if ((unread != 0) && (first_unread == -1))
1498 first_unread = mcur;
1499 if ((unread == 1) && (first_new == -1))
1504 if (first_unread == -1)
1505 first_unread = mcur;
1506 if (!e->
old && (first_new == -1))
1510 if (((op == OP_MAIN_NEXT_UNREAD) || (op == OP_MAIN_PREV_UNREAD)) && (first_unread != -1))
1514 if (((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_PREV_NEW) ||
1515 (op == OP_MAIN_NEXT_NEW_THEN_UNREAD) || (op == OP_MAIN_PREV_NEW_THEN_UNREAD)) &&
1521 if (((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_PREV_NEW) ||
1522 (op == OP_MAIN_NEXT_NEW_THEN_UNREAD) || (op == OP_MAIN_PREV_NEW_THEN_UNREAD)) &&
1527 else if (((op == OP_MAIN_NEXT_UNREAD) || (op == OP_MAIN_PREV_UNREAD) ||
1528 (op == OP_MAIN_NEXT_NEW_THEN_UNREAD) || (op == OP_MAIN_PREV_NEW_THEN_UNREAD)) &&
1529 (first_unread != -1))
1531 index = first_unread;
1537 if ((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_PREV_NEW))
1540 mutt_error(
_(
"No new messages in this limited view"));
1547 mutt_error(
_(
"No unread messages in this limited view"));
1560 if ((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_NEXT_UNREAD) ||
1561 (op == OP_MAIN_NEXT_NEW_THEN_UNREAD))
1563 if (saved_current >
index)
1568 else if (saved_current <
index)
1591 case OP_MAIN_NEXT_THREAD:
1595 case OP_MAIN_NEXT_SUBTHREAD:
1599 case OP_MAIN_PREV_THREAD:
1603 case OP_MAIN_PREV_SUBTHREAD:
1613 if ((op == OP_MAIN_NEXT_THREAD) || (op == OP_MAIN_NEXT_SUBTHREAD))
1722 for (
size_t i = 0; i < m->
msg_count; i++)
1763 (op != OP_MAIN_READ_THREAD));
1829 char buf2[256] = { 0 };
1853 struct Email *e = NULL;
1857 if (index < shared->mailbox->vcount)
1943 _(
"Undelete messages matching: ")) == 0)
1984 const char *
const c_mark_macro_prefix =
cs_subset_string(shared->
sub,
"mark_macro_prefix");
1985 char str[256] = { 0 };
1986 snprintf(str,
sizeof(str),
"%s%s", c_mark_macro_prefix,
buf_string(buf));
1990 char macro[256] = { 0 };
1991 snprintf(macro,
sizeof(macro),
"<search>~i '%s'\n",
buf_string(msg_id));
2159 if (c_pgp_auto_decode &&
2182 for (
size_t i = 0; i < m->
msg_count; i++)
2213 if (((op == OP_DECRYPT_COPY) || (op == OP_DECRYPT_SAVE)) && !
WithCrypto)
2219 const enum MessageSaveOpt save_opt = ((op == OP_SAVE) || (op == OP_DECODE_SAVE) ||
2220 (op == OP_DECRYPT_SAVE)) ?
2230 if ((rc == 0) && (save_opt ==
SAVE_MOVE))
2260 case OP_SEARCH_REVERSE:
2264 case OP_SEARCH_NEXT:
2266 case OP_SEARCH_OPPOSITE:
2313 for (
size_t i = 0; i < m->
msg_count; i++)
2371 for (
size_t i = 0; i < m->
msg_count; i++)
2457 false, (op != OP_UNDELETE_THREAD));
2461 (op != OP_UNDELETE_THREAD));
2595 int oldindex = e->
index;
2600 mutt_error(
_(
"No Message-Id. Unable to perform operation."));
2610 if (op == OP_RECONSTRUCT_THREAD)
2657 if (e2->
index == oldindex)
2670 mutt_error(
_(
"No deleted messages found in the thread"));
2693 if (op == OP_GET_MESSAGE)
2730 mutt_error(
_(
"Message is not visible in limited view"));
2774 if (shared->
attach_msg || c_read_only || (op == OP_MAIN_CHANGE_GROUP_READONLY))
2776 cp =
_(
"Open newsgroup in read-only mode");
2781 cp =
_(
"Open newsgroup");
2785 const bool c_change_folder_next =
cs_subset_bool(shared->
sub,
"change_folder_next");
2797 goto changefoldercleanup2;
2804 goto changefoldercleanup2;
2813 goto changefoldercleanup2;
2828changefoldercleanup2:
2848 "followup_to_poster") !=
MUTT_YES))
2852 (
query_quadoption(
_(
"Posting to this group not allowed, may be moderated. Continue?"),
2866 NULL, NULL, shared->
mailbox, &ea, shared->
sub);
2873 return op_reply(shared, priv, OP_REPLY);
2888 mutt_message(
_(
"No virtual folder and no Message-Id, aborting"));
2896 int msg_id_offset = 0;
2904 if (buf->
data[len - 1] ==
'>')
2905 buf->
data[len - 1] =
'\0';
2917 mutt_error(
_(
"failed to find message in notmuch database. try running 'notmuch new'."));
2980 (op == OP_MAIN_VFOLDER_FROM_QUERY_READONLY));
2984 m_query->
name = query_unencoded;
2985 query_unencoded = NULL;
2990 FREE(&query_unencoded);
3015 const char *
const c_nm_query_window_current_search =
cs_subset_string(shared->
sub,
"nm_query_window_current_search");
3016 if (!c_nm_query_window_current_search)
3025 case OP_MAIN_WINDOWED_VFOLDER_BACKWARD:
3028 case OP_MAIN_WINDOWED_VFOLDER_FORWARD:
3031 case OP_MAIN_WINDOWED_VFOLDER_RESET:
3038 mutt_str_copy(buf, c_nm_query_window_current_search,
sizeof(buf));
3101 mutt_error(
_(
"Function not permitted in attach-message mode"));
void alias_create(struct AddressList *al, const struct ConfigSubset *sub)
Create a new Alias from an Address.
struct AddressList * mutt_get_address(struct Envelope *env, const char **prefix)
Get an Address from an Envelope.
#define ARRAY_FREE(head)
Release all memory.
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
GUI display the mailboxes in a side panel.
Autocrypt end-to-end encryption.
int bool_str_toggle(struct ConfigSubset *sub, const char *name, struct Buffer *err)
Toggle the value of a bool.
Select a Mailbox from a list.
#define MUTT_SEL_NO_FLAGS
No flags are set.
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
void buf_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Convenience wrapper for the config headers.
Convenience wrapper for the core headers.
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
@ NT_MAILBOX_CHANGE
Mailbox has been changed.
#define MUTT_ACL_INSERT
Add/copy into the mailbox (used when editing a message)
#define MUTT_ACL_DELETE
Delete a message.
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
#define MUTT_ACL_WRITE
Write to a message (for flagging or linking threads)
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
@ MUTT_MH
'MH' Mailbox type
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
@ MUTT_IMAP
'IMAP' Mailbox type
@ MUTT_MAILDIR
'Maildir' Mailbox type
#define MUTT_ACL_SEEN
Change the 'seen' status of a message.
void crypt_extract_keys_from_messages(struct Mailbox *m, struct EmailArray *ea)
Extract keys from a message.
void crypt_forget_passphrase(void)
Forget a passphrase and display a message.
void mutt_flushinp(void)
Empty all the keyboard buffers.
void mutt_unget_ch(int ch)
Return a keystroke to the input buffer.
struct MuttWindow * dialog_find(struct MuttWindow *win)
Find the parent Dialog of a Window.
const char * dispatcher_get_retval_name(int rv)
Get the name of a return value.
FunctionRetval
Possible return values for NeoMutt functions.
@ FR_SUCCESS
Valid function - successfully performed.
@ FR_DONE
Exit the Dialog.
@ FR_UNKNOWN
Unknown function.
@ FR_ERROR
Valid function - error occurred.
@ FR_NOT_IMPL
Invalid function - feature not enabled.
@ FR_NO_ACTION
Valid function - no action performed.
void alias_dialog(struct Mailbox *m, struct ConfigSubset *sub)
Open the aliases dialog.
void mutt_browser_select_dir(const char *f)
Remember the last directory selected.
bool check_acl(struct Mailbox *m, AclFlags acl, const char *msg)
Check the ACLs for a function.
const struct Mapping IndexNewsHelp[]
Help Bar for the News Index dialog.
void change_folder_mailbox(struct Menu *menu, struct Mailbox *m, int *oldcount, struct IndexSharedData *shared, bool read_only)
Change to a different Mailbox by pointer.
struct Mailbox * change_folder_notmuch(struct Menu *menu, char *buf, int buflen, int *oldcount, struct IndexSharedData *shared, bool read_only)
Change to a different Notmuch Mailbox by string.
void update_index(struct Menu *menu, struct MailboxView *mv, enum MxStatus check, int oldcount, const struct IndexSharedData *shared)
Update the index.
int find_first_message(struct MailboxView *mv)
Get index of first new message.
void resort_index(struct MailboxView *mv, struct Menu *menu)
Resort the index.
int find_next_undeleted(struct MailboxView *mv, int msgno, bool uncollapse)
Find the next undeleted email.
void collapse_all(struct MailboxView *mv, struct Menu *menu, int toggle)
Collapse/uncollapse all threads.
void change_folder_string(struct Menu *menu, struct Buffer *buf, int *oldcount, struct IndexSharedData *shared, bool read_only)
Change to a different Mailbox by string.
int find_previous_undeleted(struct MailboxView *mv, int msgno, bool uncollapse)
Find the previous undeleted email.
void query_index(struct Mailbox *m, struct ConfigSubset *sub)
Perform an Alias Query and display the results.
int mutt_ev_message(struct Mailbox *m, struct EmailArray *ea, enum EvMessage action)
Edit or view a message.
Structs that make up an email.
void mutt_sort_headers(struct MailboxView *mv, bool init)
Sort emails by their headers.
bool OptNeedResort
(pseudo) used to force a re-sort
void mutt_print_message(struct Mailbox *m, struct EmailArray *ea)
Print a message.
bool mutt_select_sort(bool reverse)
Ask the user for a sort method.
void mutt_pipe_message(struct Mailbox *m, struct EmailArray *ea)
Pipe a message.
bool mutt_check_traditional_pgp(struct Mailbox *m, struct EmailArray *ea)
Check if a message has inline PGP content.
void index_bounce_message(struct Mailbox *m, struct EmailArray *ea)
Bounce an email.
int mutt_save_message(struct Mailbox *m, struct EmailArray *ea, enum MessageSaveOpt save_opt, enum MessageTransformOpt transform_opt)
Save an email.
bool mutt_edit_content_type(struct Email *e, struct Body *b, FILE *fp)
Edit the content type of an attachment.
void mutt_display_address(struct Envelope *env)
Display the address of a message.
Manage where the email is piped to external commands.
MessageTransformOpt
Message transformation option.
@ TRANSFORM_NONE
No transformation.
@ TRANSFORM_DECODE
Decode message.
@ TRANSFORM_DECRYPT
Decrypt message.
MessageSaveOpt
Message save option.
@ SAVE_MOVE
Move message to another mailbox, removing the original.
@ SAVE_COPY
Copy message, making a duplicate in another mailbox.
int mutt_file_sanitize_regex(struct Buffer *dest, const char *src)
Escape any regex-magic characters in a string.
void mutt_set_flag(struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool upd_mbox)
Set a flag on an email.
void mutt_emails_set_flag(struct Mailbox *m, struct EmailArray *ea, enum MessageType flag, bool bf)
Set flag on messages.
int mutt_thread_set_flag(struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool subthread)
Set a flag on an entire thread.
bool OptNews
(pseudo) used to change reader mode
static int op_delete(struct AliasMenuData *mdata, int op)
delete the current entry - Implements alias_function_t -
static int op_main_tag_pattern(struct AliasMenuData *mdata, int op)
Tag messages matching a pattern - Implements alias_function_t -.
static int op_main_limit(struct AliasMenuData *mdata, int op)
show only messages matching a pattern - Implements alias_function_t -
static int op_exit(struct AliasMenuData *mdata, int op)
exit this menu - Implements alias_function_t -
static int op_main_untag_pattern(struct AliasMenuData *mdata, int op)
Untag messages matching a pattern - Implements alias_function_t -.
static int op_query(struct AliasMenuData *mdata, int op)
query external program for addresses - Implements alias_function_t -
static int op_search(struct AliasMenuData *mdata, int op)
search for a regular expression - Implements alias_function_t -
static int op_create_alias(struct AliasMenuData *mdata, int op)
create an alias from a message sender - Implements alias_function_t -
static int op_sort(struct AliasMenuData *mdata, int op)
sort aliases - Implements alias_function_t -
static int op_forward_message(struct AttachPrivateData *priv, int op)
forward a message with comments - Implements attach_function_t -
static int op_bounce_message(struct AttachPrivateData *priv, int op)
remail a message to another user - Implements attach_function_t -
static int op_attachment_edit_type(struct AttachPrivateData *priv, int op)
edit attachment content type - Implements attach_function_t -
static int op_extract_keys(struct AttachPrivateData *priv, int op)
extract supported public keys - Implements attach_function_t -
static int op_reply(struct AttachPrivateData *priv, int op)
reply to a message - Implements attach_function_t -
static int op_compose_to_sender(struct AttachPrivateData *priv, int op)
compose new message to the current message sender - Implements attach_function_t -
static int op_forget_passphrase(struct AttachPrivateData *priv, int op)
wipe passphrases from memory - Implements attach_function_t -
static int op_list_subscribe(struct AttachPrivateData *priv, int op)
subscribe to a mailing list - Implements attach_function_t -
static int op_list_unsubscribe(struct AttachPrivateData *priv, int op)
unsubscribe from a mailing list - Implements attach_function_t -
static int op_check_traditional(struct AttachPrivateData *priv, int op)
check for classic PGP - Implements attach_function_t -
static int op_resend(struct AttachPrivateData *priv, int op)
use the current message as a template for a new one - Implements attach_function_t -
static int op_catchup(struct BrowserPrivateData *priv, int op)
Mark all articles in newsgroup as read - Implements browser_function_t -.
static int op_mailbox_list(struct BrowserPrivateData *priv, int op)
List mailboxes with new mail - Implements browser_function_t -.
int index_function_dispatcher(struct MuttWindow *win, int op)
Perform an Index function - Implements function_dispatcher_t -.
void dlg_autocrypt(void)
Display the Autocrypt account Menu -.
void dlg_attachment(struct ConfigSubset *sub, struct MailboxView *mv, struct Email *e, FILE *fp, bool attach_msg)
Show the attachments in a Menu -.
int mw_change_flag(struct Mailbox *m, struct EmailArray *ea, bool bf)
Change the flag on a Message -.
int mw_enter_fname(const char *prompt, struct Buffer *fname, bool mailbox, struct Mailbox *m, bool multiple, char ***files, int *numfiles, SelectFileFlags flags)
Ask the user to select a file -.
int mw_get_field(const char *prompt, struct Buffer *buf, CompletionFlags complete, enum HistoryClass hclass, const struct CompleteOps *comp_api, void *cdata)
Ask the user for a string -.
static int op_quit(struct HistoryData *hd, int op)
Quit this menu - Implements history_function_t -.
static int op_main_link_threads(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Link tagged message to the current one - Implements index_function_t -.
static int op_main_break_thread(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Break the thread in two - Implements index_function_t -.
static int op_main_root_message(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Jump to root message in thread - Implements index_function_t -.
static int op_main_delete_pattern(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Delete messages matching a pattern - Implements index_function_t -.
static int op_toggle_new(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Toggle a message's 'new' flag - Implements index_function_t -.
static int op_mail_key(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Mail a PGP public key - Implements index_function_t -.
static int op_display_message(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Display a message - Implements index_function_t -.
static int op_main_next_undeleted(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Move to the next undeleted message - Implements index_function_t -.
static int op_main_fetch_mail(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Retrieve mail from POP server - Implements index_function_t -.
static int op_list_reply(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Reply to specified mailing list - Implements index_function_t -.
static int op_delete_thread(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Delete all messages in thread - Implements index_function_t -.
static int op_main_next_unread_mailbox(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Open next mailbox with unread mail - Implements index_function_t -.
static int op_pipe(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Pipe message/attachment to a shell command - Implements index_function_t -.
static int op_main_prev_undeleted(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Move to the previous undeleted message - Implements index_function_t -.
static int op_prev_entry(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Move to the previous entry - Implements index_function_t -.
static int op_next_entry(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Move to the next entry - Implements index_function_t -.
static int op_main_modify_tags(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Modify (notmuch/imap) tags - Implements index_function_t -.
static int op_main_sync_folder(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Save changes to mailbox - Implements index_function_t -.
static int op_autocrypt_acct_menu(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Manage autocrypt accounts - Implements index_function_t -.
static int op_end_cond(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
End of conditional execution (noop) - Implements index_function_t -.
static int op_edit_raw_message(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Edit the raw message (edit and edit-raw-message are synonyms) - Implements index_function_t -.
static int op_get_message(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Get parent of the current message - Implements index_function_t -.
static int op_main_next_new(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Jump to the next new message - Implements index_function_t -.
static int op_main_change_group(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Open a different newsgroup - Implements index_function_t -.
static int op_view_attachments(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Show MIME attachments - Implements index_function_t -.
static int op_main_vfolder_from_query(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Generate virtual folder from query - Implements index_function_t -.
static int op_flag_message(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Toggle a message's 'important' flag - Implements index_function_t -.
static int op_main_imap_logout_all(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Logout from all IMAP servers - Implements index_function_t -.
static int op_main_read_thread(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Mark the current thread as read - Implements index_function_t -.
static int op_recall_message(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Recall a postponed message - Implements index_function_t -.
static int op_get_children(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Get all children of the current message - Implements index_function_t -.
static int op_toggle_write(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Toggle whether the mailbox will be rewritten - Implements index_function_t -.
static int op_save(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Make decrypted copy - Implements index_function_t -.
static int op_undelete_thread(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Undelete all messages in thread - Implements index_function_t -.
static int op_edit_label(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Add, change, or delete a message's label - Implements index_function_t -.
static int op_main_entire_thread(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Read entire thread of the current message - Implements index_function_t -.
static int op_display_address(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Display full address of sender - Implements index_function_t -.
static int op_post(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Followup to newsgroup - Implements index_function_t -.
static int op_tag(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Tag the current entry - Implements index_function_t -.
static int op_tag_thread(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Tag the current thread - Implements index_function_t -.
static int op_main_collapse_thread(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Collapse/uncollapse current thread - Implements index_function_t -.
static int op_alias_dialog(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Open the aliases dialog - Implements index_function_t -.
static int op_main_imap_fetch(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Force retrieval of mail from IMAP server - Implements index_function_t -.
static int op_main_quasi_delete(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Delete from NeoMutt, don't touch on disk - Implements index_function_t -.
static int op_undelete(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Undelete the current entry - Implements index_function_t -.
static int op_main_collapse_all(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Collapse/uncollapse all threads - Implements index_function_t -.
static int op_jump(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Jump to an index number - Implements index_function_t -.
static int op_main_undelete_pattern(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Undelete messages matching a pattern - Implements index_function_t -.
static int op_mark_msg(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Create a hotkey macro for the current message - Implements index_function_t -.
static int op_main_windowed_vfolder(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Shifts virtual folder time window - Implements index_function_t -.
static int op_main_set_flag(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Set a status flag on a message - Implements index_function_t -.
static int op_main_next_thread(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Jump to the next thread - Implements index_function_t -.
static int op_group_reply(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Reply to all recipients - Implements index_function_t -.
static int op_main_show_limit(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Show currently active limit pattern - Implements index_function_t -.
static int op_main_change_folder(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Open a different folder - Implements index_function_t -.
static int op_mail(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Compose a new mail message - Implements index_function_t -.
static int op_print(struct IndexSharedData *shared, struct IndexPrivateData *priv, int op)
Print the current entry - Implements index_function_t -.
#define mutt_warning(...)
#define mutt_message(...)
#define mutt_debug(LEVEL,...)
Convenience wrapper for the gui headers.
void * mutt_hash_find(const struct HashTable *table, const char *strkey)
Find the HashElem data in a Hash Table element using a key.
Read/write command history from/to a file.
@ HC_OTHER
Miscellaneous strings.
void mutt_startup_shutdown_hook(HookFlags type)
Execute any startup/shutdown hooks.
Parse and execute user-defined hooks.
#define MUTT_SHUTDOWN_HOOK
shutdown-hook: run when leaving NeoMutt
void imap_logout_all(void)
Close all open connections.
enum MxStatus imap_check_mailbox(struct Mailbox *m, bool force)
Use the NOOP or IDLE command to poll for new mail.
const struct MenuFuncOp OpIndex[]
Functions for the Index Menu.
bool index_next_undeleted(struct MuttWindow *win_index)
Select the next undeleted Email (if possible)
static bool resolve_email(struct IndexPrivateData *priv, struct IndexSharedData *shared, enum ResolveMethod rm)
Pick the next Email to advance the cursor to.
const struct MenuOpSeq IndexDefaultBindings[]
Key bindings for the Index Menu.
static bool prereq(struct IndexSharedData *shared, struct Menu *menu, CheckFlags checks)
Check the pre-requisites for a function.
static const struct IndexFunction IndexFunctions[]
All the NeoMutt functions that the Index supports.
ResolveMethod
How to advance the cursor.
@ RESOLVE_NEXT_SUBTHREAD
Next sibling sub-thread.
@ RESOLVE_NEXT_UNDELETED
Next undeleted email.
@ RESOLVE_NEXT_EMAIL
Next email, whatever its state.
@ RESOLVE_NEXT_THREAD
Next top-level thread.
uint8_t CheckFlags
Flags, e.g. CHECK_IN_MAILBOX.
#define CHECK_NO_FLAGS
No flags are set.
#define CHECK_ATTACH
Is the user in message-attach mode?
#define CHECK_VISIBLE
Is the selected message visible in the index?
#define CHECK_IN_MAILBOX
Is there a mailbox open?
#define CHECK_READONLY
Is the mailbox readonly?
#define CHECK_MSGCOUNT
Are there any messages?
#define NT_INDEX_EMAIL
Email has changed.
void index_shared_data_set_email(struct IndexSharedData *shared, struct Email *e)
Set the current Email for the Index and friends.
Data shared between Index, Pager and Sidebar.
enum CommandResult km_bind(char *s, enum MenuType menu, int op, char *macro, char *desc)
Bind a key to a macro.
@ LL_DEBUG1
Log at debug level 1.
@ LL_NOTIFY
Log of notifications.
void msgwin_clear_text(struct MuttWindow *win)
Clear the text in the Message Window.
Convenience wrapper for the library headers.
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Many unsorted constants and some structs.
#define MUTT_COMP_NO_FLAGS
No flags are set.
@ MUTT_UNDELETE
Messages to be un-deleted.
@ MUTT_LIMIT
Messages in limited view.
@ MUTT_UNTAG
Messages to be un-tagged.
@ MUTT_READ
Messages that have been read.
@ MUTT_PURGE
Messages to be purged (bypass trash)
@ MUTT_TAG
Tagged messages.
@ MUTT_FLAG
Flagged messages.
@ MUTT_DELETE
Messages to be deleted.
struct Mailbox * mutt_mailbox_next_unread(struct Mailbox *m_cur, struct Buffer *s)
Find next mailbox with unread mail.
struct Mailbox * mutt_mailbox_next(struct Mailbox *m_cur, struct Buffer *s)
Incoming folders completion routine.
bool mutt_mailbox_list(void)
Show a message with the list of mailboxes with new mail.
Mailbox helper functions.
bool mutt_link_threads(struct Email *parent, struct EmailArray *children, struct Mailbox *m)
Forcibly link threads together.
void mutt_draw_tree(struct ThreadsContext *tctx)
Draw a tree of threaded emails.
int mutt_messages_in_thread(struct Mailbox *m, struct Email *e, enum MessageInThread mit)
Count the messages in a thread.
off_t mutt_set_vnum(struct Mailbox *m)
Set the virtual index number of all the messages in a mailbox.
bool mutt_thread_can_collapse(struct Email *e)
Check whether a thread can be collapsed.
int mutt_parent_message(struct Email *e, bool find_root)
Find the parent of a message.
struct HashTable * mutt_make_id_hash(struct Mailbox *m)
Create a Hash Table for message-ids.
Create/manipulate threading in emails.
#define mutt_thread_next_unread(e)
#define mutt_using_threads()
#define mutt_previous_thread(e)
#define mutt_uncollapse_thread(e)
@ MIT_POSITION
Our position in the thread.
#define mutt_next_subthread(e)
#define mutt_thread_contains_unread(e)
#define mutt_previous_subthread(e)
#define mutt_next_thread(e)
#define mutt_collapse_thread(e)
bool window_is_focused(const struct MuttWindow *win)
Does the given Window have the focus?
struct MuttWindow * window_set_focus(struct MuttWindow *win)
Set the Window focus.
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Some miscellaneous functions.
struct Email * mutt_get_virt_email(struct Mailbox *m, int vnum)
Get a virtual Email.
bool mutt_limit_current_thread(struct MailboxView *mv, struct Email *e)
Limit the email view to the current thread.
void mview_free(struct MailboxView **ptr)
Free a MailboxView.
int ea_add_tagged(struct EmailArray *ea, struct MailboxView *mv, struct Email *e, bool use_tagged)
Get an array of the tagged Emails.
bool message_is_tagged(struct Email *e)
Is a message in the index tagged (and within limit)
bool mview_has_limit(const struct MailboxView *mv)
Is a limit active?
int mx_tags_edit(struct Mailbox *m, const char *tags, struct Buffer *buf)
Start the tag editor of the mailbox.
int mx_msg_close(struct Mailbox *m, struct Message **ptr)
Close a message.
void mx_fastclose_mailbox(struct Mailbox *m, bool keep_account)
Free up memory associated with the Mailbox.
struct Mailbox * mx_mbox_find2(const char *path)
Find a Mailbox on an Account.
struct Message * mx_msg_open(struct Mailbox *m, struct Email *e)
Return a stream pointer for a message.
bool mx_tags_is_supported(struct Mailbox *m)
Return true if mailbox support tagging.
int mx_tags_commit(struct Mailbox *m, struct Email *e, const char *tags)
Save tags to the Mailbox - Wrapper for MxOps::tags_commit()
int mx_toggle_write(struct Mailbox *m)
Toggle the mailbox's readonly flag.
enum MxStatus mx_mbox_sync(struct Mailbox *m)
Save changes to mailbox.
enum MxStatus mx_mbox_close(struct Mailbox *m)
Save changes and close mailbox.
MxStatus
Return values from mbox_check(), mbox_check_stats(), mbox_sync(), and mbox_close()
@ MX_STATUS_OK
No changes.
@ MX_STATUS_REOPENED
Mailbox was reopened.
@ MX_STATUS_NEW_MAIL
New mail received in Mailbox.
API for encryption/signing of emails.
#define PGP_TRADITIONAL_CHECKED
Email has a traditional (inline) signature.
#define APPLICATION_PGP
Use PGP to encrypt/sign.
@ NT_GLOBAL_SHUTDOWN
NeoMutt is about to close.
Usenet network mailbox type; talk to an NNTP server.
int nntp_check_msgid(struct Mailbox *m, const char *msgid)
Fetch article by Message-ID.
int nntp_check_children(struct Mailbox *m, const char *msgid)
Fetch children of article with the Message-ID.
void nntp_mailbox(struct Mailbox *m, char *buf, size_t buflen)
Get first newsgroup with new messages.
struct NntpMboxData * mutt_newsgroup_catchup(struct Mailbox *m, struct NntpAccountData *adata, char *group)
Catchup newsgroup.
struct NntpAccountData * CurrentNewsSrv
Current NNTP news server.
struct NntpAccountData * nntp_select_server(struct Mailbox *m, const char *server, bool leave_lock)
Open a connection to an NNTP server.
Nntp-specific Mailbox data.
@ NT_MAILBOX
Mailbox has changed, NotifyMailbox, EventMailbox.
@ NT_INDEX
Index data has changed, NotifyIndex, IndexSharedData.
@ NT_GLOBAL
Not object-related, NotifyGlobal.
const struct CompleteOps CompleteNmQueryOps
Auto-Completion of NmQuerys.
void nm_db_longrun_done(struct Mailbox *m)
Finish a long transaction.
void nm_db_longrun_init(struct Mailbox *m, bool writable)
Start a long transaction.
Notmuch virtual mailbox type.
void nm_query_window_reset(void)
Resets the vfolder window position to the present.
int nm_read_entire_thread(struct Mailbox *m, struct Email *e)
Get the entire thread of an email.
void nm_query_window_backward(void)
Function to move the current search window backward in time.
bool nm_query_window_available(void)
Are windowed queries enabled for use?
bool nm_message_is_still_queried(struct Mailbox *m, struct Email *e)
Is a message still visible in the query?
void nm_query_window_forward(void)
Function to move the current search window forward in time.
const char * opcodes_get_name(int op)
Get the name of an opcode.
Match patterns to emails.
int mutt_search_command(struct MailboxView *mv, struct Menu *menu, int cur, struct SearchState *state, SearchFlags flags)
Perform a search.
int mutt_pattern_func(struct MailboxView *mv, int op, char *prompt)
Perform some Pattern matching.
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
void pop_fetch_mail(void)
Fetch messages and save them in $spool_file.
@ MUTT_PROGRESS_WRITE
Progress tracks elements, according to $write_inc
struct Progress * progress_new(enum ProgressType type, size_t size)
Create a new Progress Bar.
void progress_free(struct Progress **ptr)
Free a Progress Bar.
void progress_set_message(struct Progress *progress, const char *fmt,...) __attribute__((__format__(__printf__
bool progress_update(struct Progress *progress, size_t pos, int percent)
Update the state of the progress bar.
Prototypes for many functions.
@ EVM_VIEW
View the message.
@ EVM_EDIT
Edit the message.
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
enum QuadOption query_quadoption(const char *prompt, struct ConfigSubset *sub, const char *name)
Ask the user a quad-question.
#define STAILQ_FIRST(head)
#define STAILQ_FOREACH(var, head, field)
#define STAILQ_EMPTY(head)
#define STAILQ_NEXT(elm, field)
#define SEARCH_OPPOSITE
Search in the opposite direction.
uint8_t SearchFlags
Flags for a specific search, e.g. SEARCH_PROMPT.
#define SEARCH_NO_FLAGS
No flags are set.
#define SEARCH_PROMPT
Ask for search input.
Convenience wrapper for the send headers.
int mutt_resend_message(FILE *fp, struct Mailbox *m, struct Email *e_cur, struct ConfigSubset *sub)
Resend an email.
bool mutt_send_list_unsubscribe(struct Mailbox *m, struct Email *e)
Send a mailing-list unsubscription email.
int mutt_send_message(SendFlags flags, struct Email *e_templ, const char *tempfile, struct Mailbox *m, struct EmailArray *ea, struct ConfigSubset *sub)
Send an email.
bool mutt_send_list_subscribe(struct Mailbox *m, struct Email *e)
Send a mailing-list subscription email.
#define SEND_GROUP_CHAT_REPLY
Reply to all recipients preserving To/Cc.
uint32_t SendFlags
Flags for mutt_send_message(), e.g. SEND_REPLY.
#define SEND_GROUP_REPLY
Reply to all.
#define SEND_LIST_REPLY
Reply to mailing list.
#define SEND_KEY
Mail a PGP public key.
#define SEND_POSTPONED
Recall a postponed email.
#define SEND_TO_SENDER
Compose new email to sender.
#define SEND_NO_FLAGS
No flags are set.
#define SEND_REPLY
Reply to sender.
#define SEND_NEWS
Reply to a news article.
#define SEND_FORWARD
Forward email.
String manipulation buffer.
size_t dsize
Length of data.
char * data
Pointer to data.
The envelope/body of an email.
bool visible
Is this message part of the view?
struct Envelope * env
Envelope information.
bool collapsed
Is this message part of a collapsed thread?
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
struct Body * body
List of MIME parts.
bool old
Email is seen, but unread.
bool attach_del
Has an attachment marked for deletion.
bool flagged
Marked important?
bool threaded
Used for threading.
const struct AttrColor * attr_color
Color-pair to use when displaying in the index.
int vnum
Virtual message number.
struct TagList tags
For drivers that support server tagging.
bool deleted
Email is deleted.
int index
The absolute (unsorted) message number.
bool quasi_deleted
Deleted from neomutt, but not modified on disk.
bool tagged
Email is tagged.
char * followup_to
List of 'followup-to' fields.
char * message_id
Message ID.
struct ListHead references
message references (in reverse order)
struct ListHead in_reply_to
in-reply-to header content
An Event that happened to a Mailbox.
int op
Op code, e.g. OP_MAIN_LIMIT.
index_function_t function
Function to call.
int flags
Prerequisites for the function, e.g. CHECK_IN_MAILBOX.
Private state data for the Index.
struct MuttWindow * win_index
Window for the Index.
struct IndexSharedData * shared
Shared Index data.
bool tag_prefix
tag-prefix has been pressed
struct Menu * menu
Menu controlling the index.
int oldcount
Old count of mails in the mailbox.
Data shared between Index, Pager and Sidebar.
struct Email * email
Currently selected Email.
struct Mailbox * mailbox
Current Mailbox.
bool attach_msg
Are we in "attach message" mode?
struct ConfigSubset * sub
Config set to use.
struct MailboxView * mailbox_view
Current Mailbox view.
struct SearchState * search_state
State of the current search.
struct Notify * notify
Notifications: NotifyIndex, IndexSharedData.
bool collapsed
Are all threads collapsed?
struct Menu * menu
Needed for pattern compilation.
struct ThreadsContext * threads
Threads context.
struct Mailbox * mailbox
Current Mailbox.
char * pattern
Limit pattern string.
int vcount
The number of virtual messages.
bool changed
Mailbox has been modified.
int msg_count
Total number of messages.
AclFlags rights
ACL bits, see AclFlags.
enum MailboxType type
Mailbox type.
void * mdata
Driver specific data.
struct Email ** emails
Array of Emails.
char * name
A short name for the Mailbox.
struct Notify * notify
Notifications: NotifyMailbox, EventMailbox.
struct HashTable * id_hash
Hash Table: "message-id" -> Email.
struct Buffer pathbuf
Path of the Mailbox.
bool readonly
Don't allow changes to the mailbox.
int msg_tagged
How many messages are tagged?
bool verbose
Display status messages?
A local copy of an email.
FILE * fp
pointer to the message data
const struct Mapping * help_data
Data for the Help Bar.
void * wdata
Private data.
struct MuttWindow * parent
Parent Window.
Container for Accounts, Notifications.
struct Notify * notify
Notifications handler.
struct ConfigSubset * sub
Inherited config items.
NNTP-specific Mailbox data -.
bool reverse
search backwards
struct PatternList * pattern
compiled search pattern
void mutt_break_thread(struct Email *e)
Break the email Thread.
@ MENU_INDEX
Index panel (list of emails)