NeoMutt  2023-03-22-27-g3cb248
Teaching an old dog new tricks
DOXYGEN
dlg_alias.c
Go to the documentation of this file.
1
74#include "config.h"
75#include <stdbool.h>
76#include <stdint.h>
77#include <stdio.h>
78#include <string.h>
79#include "mutt/lib.h"
80#include "address/lib.h"
81#include "config/lib.h"
82#include "email/lib.h"
83#include "core/lib.h"
84#include "gui/lib.h"
85#include "lib.h"
86#include "menu/lib.h"
87#include "pattern/lib.h"
88#include "send/lib.h"
89#include "alias.h"
90#include "format_flags.h"
91#include "functions.h"
92#include "gui.h"
93#include "keymap.h"
94#include "mutt_logging.h"
95#include "muttlib.h"
96#include "opcodes.h"
97
99static const struct Mapping AliasHelp[] = {
100 // clang-format off
101 { N_("Exit"), OP_EXIT },
102 { N_("Del"), OP_DELETE },
103 { N_("Undel"), OP_UNDELETE },
104 { N_("Sort"), OP_SORT },
105 { N_("Rev-Sort"), OP_SORT_REVERSE },
106 { N_("Select"), OP_GENERIC_SELECT_ENTRY },
107 { N_("Help"), OP_HELP },
108 { NULL, 0 },
109 // clang-format on
110};
111
124static const char *alias_format_str(char *buf, size_t buflen, size_t col, int cols,
125 char op, const char *src, const char *prec,
126 const char *if_str, const char *else_str,
127 intptr_t data, MuttFormatFlags flags)
128{
129 char tmp[1024];
130 struct AliasView *av = (struct AliasView *) data;
131 struct Alias *alias = av->alias;
132
133 switch (op)
134 {
135 case 'a':
136 mutt_format_s(buf, buflen, prec, alias->name);
137 break;
138 case 'c':
139 mutt_format_s(buf, buflen, prec, alias->comment);
140 break;
141 case 'f':
142 snprintf(tmp, sizeof(tmp), "%%%ss", prec);
143 snprintf(buf, buflen, tmp, av->is_deleted ? "D" : " ");
144 break;
145 case 'n':
146 snprintf(tmp, sizeof(tmp), "%%%sd", prec);
147 snprintf(buf, buflen, tmp, av->num + 1);
148 break;
149 case 'r':
150 {
151 struct Buffer *tmpbuf = mutt_buffer_pool_get();
152 mutt_addrlist_write(&alias->addr, tmpbuf, true);
153 mutt_str_copy(tmp, mutt_buffer_string(tmpbuf), sizeof(tmp));
155 mutt_format_s(buf, buflen, prec, tmp);
156 break;
157 }
158 case 't':
159 buf[0] = av->is_tagged ? '*' : ' ';
160 buf[1] = '\0';
161 break;
162 }
163
164 return src;
165}
166
172static void alias_make_entry(struct Menu *menu, char *buf, size_t buflen, int line)
173{
174 const struct AliasMenuData *mdata = menu->mdata;
175 const struct AliasViewArray *ava = &mdata->ava;
176 const struct AliasView *av = ARRAY_GET(ava, line);
177
178 const char *const c_alias_format = cs_subset_string(mdata->sub, "alias_format");
179
180 mutt_expando_format(buf, buflen, 0, menu->win->state.cols, NONULL(c_alias_format),
182}
183
187static int alias_tag(struct Menu *menu, int sel, int act)
188{
189 const struct AliasMenuData *mdata = menu->mdata;
190 const struct AliasViewArray *ava = &mdata->ava;
191 struct AliasView *av = ARRAY_GET(ava, sel);
192
193 bool ot = av->is_tagged;
194
195 av->is_tagged = ((act >= 0) ? act : !av->is_tagged);
196
197 return av->is_tagged - ot;
198}
199
204{
205 if (nc->event_type != NT_ALIAS)
206 return 0;
207 if (!nc->global_data || !nc->event_data)
208 return -1;
209
210 struct EventAlias *ev_a = nc->event_data;
211 struct Menu *menu = nc->global_data;
212 struct AliasMenuData *mdata = menu->mdata;
213 struct Alias *alias = ev_a->alias;
214
215 if (nc->event_subtype == NT_ALIAS_ADD)
216 {
217 alias_array_alias_add(&mdata->ava, alias);
218
219 if (alias_array_count_visible(&mdata->ava) != ARRAY_SIZE(&mdata->ava))
220 {
221 mutt_pattern_alias_func(NULL, mdata, menu);
222 }
223 }
224 else if (nc->event_subtype == NT_ALIAS_DELETE)
225 {
226 alias_array_alias_delete(&mdata->ava, alias);
227
228 int vcount = alias_array_count_visible(&mdata->ava);
229 int index = menu_get_index(menu);
230 if ((index > (vcount - 1)) && (index > 0))
231 menu_set_index(menu, index - 1);
232 }
233
234 alias_array_sort(&mdata->ava, mdata->sub);
235
236 menu->max = alias_array_count_visible(&mdata->ava);
238 mutt_debug(LL_DEBUG5, "alias done, request WA_RECALC, MENU_REDRAW_FULL\n");
239
240 return 0;
241}
242
251{
252 if (nc->event_type != NT_WINDOW)
253 return 0;
254 if (!nc->global_data || !nc->event_data)
255 return -1;
257 return 0;
258
259 struct MuttWindow *win_menu = nc->global_data;
260 struct EventWindow *ev_w = nc->event_data;
261 if (ev_w->win != win_menu)
262 return 0;
263
264 struct Menu *menu = win_menu->wdata;
265
269
270 mutt_debug(LL_DEBUG5, "window delete done\n");
271 return 0;
272}
273
279static struct MuttWindow *alias_dialog_new(struct AliasMenuData *mdata)
280{
282
283 struct Menu *menu = dlg->wdata;
284
286 menu->custom_search = true;
287 menu->tag = alias_tag;
288 menu->max = alias_array_count_visible(&mdata->ava);
289 menu->mdata = mdata;
290 menu->mdata_free = NULL; // Menu doesn't own the data
291
292 struct MuttWindow *win_menu = menu->win;
293
294 // Override the Simple Dialog's recalc()
295 win_menu->recalc = alias_recalc;
296
297 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
298 alias_set_title(sbar, mdata->title, mdata->limit);
299
300 // NT_COLOR is handled by the SimpleDialog
304
305 return dlg;
306}
307
314static bool dlg_select_alias(struct Buffer *buf, struct AliasMenuData *mdata)
315{
316 if (ARRAY_EMPTY(&mdata->ava))
317 {
318 mutt_warning(_("You have no aliases"));
319 return false;
320 }
321
322 mdata->query = buf;
323 mdata->title = mutt_str_dup(_("Aliases"));
324
325 struct MuttWindow *dlg = alias_dialog_new(mdata);
326 struct Menu *menu = dlg->wdata;
327 struct MuttWindow *win_sbar = window_find_child(dlg, WT_STATUS_BAR);
328 mdata->menu = menu;
329 mdata->sbar = win_sbar;
330
331 alias_array_sort(&mdata->ava, mdata->sub);
332
333 struct AliasView *avp = NULL;
334 ARRAY_FOREACH(avp, &mdata->ava)
335 {
336 avp->num = ARRAY_FOREACH_IDX;
337 }
338
339 // ---------------------------------------------------------------------------
340 // Event Loop
341 int rc = 0;
342 int op = OP_NULL;
343 do
344 {
345 menu_tagging_dispatcher(menu->win, op);
346 window_redraw(NULL);
347
348 op = km_dokey(MENU_ALIAS);
349 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
350 if (op < 0)
351 continue;
352 if (op == OP_NULL)
353 {
355 continue;
356 }
358
359 rc = alias_function_dispatcher(dlg, op);
360 if (rc == FR_UNKNOWN)
361 rc = menu_function_dispatcher(menu->win, op);
362 if (rc == FR_UNKNOWN)
363 rc = global_function_dispatcher(NULL, op);
364 } while ((rc != FR_DONE) && (rc != FR_CONTINUE));
365 // ---------------------------------------------------------------------------
366
367 simple_dialog_free(&dlg);
368 window_redraw(NULL);
369 return (rc == FR_CONTINUE); // Was a selection made?
370}
371
384int alias_complete(char *buf, size_t buflen, struct ConfigSubset *sub)
385{
386 struct Alias *np = NULL;
387 char bestname[8192] = { 0 };
388
389 struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
390 mdata.limit = mutt_str_dup(buf);
391
392 if (buf[0] != '\0')
393 {
394 TAILQ_FOREACH(np, &Aliases, entries)
395 {
396 if (np->name && mutt_strn_equal(np->name, buf, strlen(buf)))
397 {
398 if (bestname[0] == '\0') /* init */
399 {
400 mutt_str_copy(bestname, np->name,
401 MIN(mutt_str_len(np->name) + 1, sizeof(bestname)));
402 }
403 else
404 {
405 int i;
406 for (i = 0; np->name[i] && (np->name[i] == bestname[i]); i++)
407 ; // do nothing
408
409 bestname[i] = '\0';
410 }
411 }
412 }
413
414 if (bestname[0] == '\0')
415 {
416 // Create a View Array of all the Aliases
417 FREE(&mdata.limit);
418 TAILQ_FOREACH(np, &Aliases, entries)
419 {
421 }
422 }
423 else
424 {
425 /* fake the pattern for menu title */
426 char *mtitle = NULL;
427 mutt_str_asprintf(&mtitle, "~f ^%s", buf);
428 FREE(&mdata.limit);
429 mdata.limit = mtitle;
430
431 if (!mutt_str_equal(bestname, buf))
432 {
433 /* we are adding something to the completion */
434 mutt_str_copy(buf, bestname, mutt_str_len(bestname) + 1);
435 FREE(&mdata.limit);
436 return 1;
437 }
438
439 /* build alias list and show it */
440 TAILQ_FOREACH(np, &Aliases, entries)
441 {
442 int aasize = alias_array_alias_add(&mdata.ava, np);
443
444 struct AliasView *av = ARRAY_GET(&mdata.ava, aasize - 1);
445
446 if (np->name && !mutt_strn_equal(np->name, buf, strlen(buf)))
447 {
448 av->is_visible = false;
449 }
450 }
451 }
452 }
453
454 if (ARRAY_EMPTY(&mdata.ava))
455 {
456 TAILQ_FOREACH(np, &Aliases, entries)
457 {
458 alias_array_alias_add(&mdata.ava, np);
459 }
460
461 mutt_pattern_alias_func(NULL, &mdata, NULL);
462 }
463
464 if (!dlg_select_alias(NULL, &mdata))
465 goto done;
466
467 buf[0] = '\0';
468
469 // Extract the selected aliases
470 struct Buffer *tmpbuf = mutt_buffer_pool_get();
471 struct AliasView *avp = NULL;
472 ARRAY_FOREACH(avp, &mdata.ava)
473 {
474 if (!avp->is_tagged)
475 continue;
476
477 mutt_addrlist_write(&avp->alias->addr, tmpbuf, true);
478 }
479 mutt_str_copy(buf, mutt_buffer_string(tmpbuf), buflen);
481
482done:
483 // Process any deleted aliases
484 ARRAY_FOREACH(avp, &mdata.ava)
485 {
486 if (!avp->is_deleted)
487 continue;
488
489 TAILQ_REMOVE(&Aliases, avp->alias, entries);
490 alias_free(&avp->alias);
491 }
492
493 ARRAY_FREE(&mdata.ava);
494 FREE(&mdata.limit);
495 FREE(&mdata.title);
496
497 return 0;
498}
499
505void alias_dialog(struct Mailbox *m, struct ConfigSubset *sub)
506{
507 struct Alias *np = NULL;
508
509 struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
510
511 // Create a View Array of all the Aliases
512 TAILQ_FOREACH(np, &Aliases, entries)
513 {
515 }
516
517 if (!dlg_select_alias(NULL, &mdata))
518 goto done;
519
520 // Prepare the "To:" field of a new email
521 struct Email *e = email_new();
522 e->env = mutt_env_new();
523
524 struct AliasView *avp = NULL;
525 ARRAY_FOREACH(avp, &mdata.ava)
526 {
527 if (!avp->is_tagged)
528 continue;
529
530 struct AddressList al_copy = TAILQ_HEAD_INITIALIZER(al_copy);
531 if (alias_to_addrlist(&al_copy, avp->alias))
532 {
533 mutt_addrlist_copy(&e->env->to, &al_copy, false);
534 mutt_addrlist_clear(&al_copy);
535 }
536 }
537
538 mutt_send_message(SEND_REVIEW_TO, e, NULL, m, NULL, sub);
539
540done:
541 // Process any deleted aliases
542 ARRAY_FOREACH(avp, &mdata.ava)
543 {
544 if (avp->is_deleted)
545 {
546 TAILQ_REMOVE(&Aliases, avp->alias, entries);
547 alias_free(&avp->alias);
548 }
549 }
550
551 ARRAY_FREE(&mdata.ava);
552 FREE(&mdata.limit);
553 FREE(&mdata.title);
554}
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:745
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1443
size_t mutt_addrlist_write(const struct AddressList *al, struct Buffer *buf, bool display)
Write an Address to a buffer.
Definition: address.c:1192
Email Address Handling.
void alias_array_sort(struct AliasViewArray *ava, const struct ConfigSubset *sub)
Sort and reindex an AliasViewArray.
Definition: sort.c:156
void alias_free(struct Alias **ptr)
Free an Alias.
Definition: alias.c:641
struct AliasList Aliases
List of all the user's email aliases.
Definition: alias.c:58
Representation of a single alias to an email address.
@ NT_ALIAS_ADD
Alias has been added.
Definition: alias.h:54
@ NT_ALIAS_DELETE
Alias is about to be deleted.
Definition: alias.h:55
int alias_array_count_visible(struct AliasViewArray *ava)
Count number of visible Aliases.
Definition: array.c:95
int alias_array_alias_delete(struct AliasViewArray *ava, const struct Alias *alias)
Delete an Alias from the AliasViewArray.
Definition: array.c:73
int alias_array_alias_add(struct AliasViewArray *ava, struct Alias *alias)
Add an Alias to the AliasViewArray.
Definition: array.c:47
#define ARRAY_FOREACH(elem, head)
Iterate over all elements of the array.
Definition: array.h:211
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:73
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:86
#define ARRAY_FREE(head)
Release all memory.
Definition: array.h:203
#define ARRAY_GET(head, idx)
Return the element at index.
Definition: array.h:108
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
Definition: array.h:57
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:78
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
Convenience wrapper for the config headers.
Convenience wrapper for the core headers.
void mutt_format_s(char *buf, size_t buflen, const char *prec, const char *s)
Format a simple string.
Definition: curs_lib.c:794
@ FR_DONE
Exit the Dialog.
Definition: dispatcher.h:35
@ FR_UNKNOWN
Unknown function.
Definition: dispatcher.h:33
@ FR_CONTINUE
Remain in the Dialog.
Definition: dispatcher.h:34
static const struct Mapping AliasHelp[]
Help Bar for the Alias dialog (address book)
Definition: dlg_alias.c:99
static bool dlg_select_alias(struct Buffer *buf, struct AliasMenuData *mdata)
Display a menu of Aliases.
Definition: dlg_alias.c:314
void alias_dialog(struct Mailbox *m, struct ConfigSubset *sub)
Open the aliases dialog.
Definition: dlg_alias.c:505
int alias_complete(char *buf, size_t buflen, struct ConfigSubset *sub)
Alias completion routine.
Definition: dlg_alias.c:384
static struct MuttWindow * alias_dialog_new(struct AliasMenuData *mdata)
Create an Alias Selection Dialog.
Definition: dlg_alias.c:279
bool alias_to_addrlist(struct AddressList *al, struct Alias *alias)
Turn an Alias into an AddressList.
Definition: dlg_query.c:118
struct Email * email_new(void)
Create a new Email.
Definition: email.c:78
Structs that make up an email.
struct Envelope * mutt_env_new(void)
Create a new Envelope.
Definition: envelope.c:43
Flags to control mutt_expando_format()
#define MUTT_FORMAT_ARROWCURSOR
Reserve space for arrow_cursor.
Definition: format_flags.h:35
uint8_t MuttFormatFlags
Flags for mutt_expando_format(), e.g. MUTT_FORMAT_FORCESUBJ.
Definition: format_flags.h:29
int menu_tagging_dispatcher(struct MuttWindow *win, int op)
Perform tagging operations on the Menu - Implements function_dispatcher_t -.
Definition: tagging.c:223
int global_function_dispatcher(struct MuttWindow *win, int op)
Perform a Global function - Implements function_dispatcher_t -.
Definition: global.c:164
int menu_function_dispatcher(struct MuttWindow *win, int op)
Perform a Menu function - Implements function_dispatcher_t -.
Definition: functions.c:320
int alias_function_dispatcher(struct MuttWindow *win, int op)
Perform a Alias function - Implements function_dispatcher_t -.
Definition: functions.c:333
static const char * alias_format_str(char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
Format a string for the alias list - Implements format_t -.
Definition: dlg_alias.c:124
void mutt_expando_format(char *buf, size_t buflen, size_t col, int cols, const char *src, format_t callback, intptr_t data, MuttFormatFlags flags)
Expand expandos (x) in a string -.
Definition: muttlib.c:726
#define mutt_warning(...)
Definition: logging.h:85
#define mutt_debug(LEVEL,...)
Definition: logging.h:84
static void alias_make_entry(struct Menu *menu, char *buf, size_t buflen, int line)
Format a menu item for the alias list - Implements Menu::make_entry() -.
Definition: dlg_alias.c:172
static int alias_tag(struct Menu *menu, int sel, int act)
Tag some aliases - Implements Menu::tag() -.
Definition: dlg_alias.c:187
static int alias_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_alias.c:250
static int alias_alias_observer(struct NotifyCallback *nc)
Notification that an Alias has changed - Implements observer_t -.
Definition: dlg_alias.c:203
int alias_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: gui.c:43
int alias_recalc(struct MuttWindow *win)
Recalculate the display of the Alias Window - Implements MuttWindow::recalc() -.
Definition: gui.c:89
Convenience wrapper for the gui headers.
void simple_dialog_free(struct MuttWindow **ptr)
Destroy a simple index Dialog.
Definition: simple.c:166
struct MuttWindow * simple_dialog_new(enum MenuType mtype, enum WindowType wtype, const struct Mapping *help_data)
Create a simple index Dialog.
Definition: simple.c:129
void alias_set_title(struct MuttWindow *sbar, char *menu_name, char *limit)
Create a title string for the Menu.
Definition: gui.c:69
Shared code for the Alias and Query Dialogs.
int km_dokey(enum MenuType mtype)
Determine what a keypress should do.
Definition: keymap.c:797
void km_error_key(enum MenuType mtype)
Handle an unbound key sequence.
Definition: keymap.c:1065
Manage keymappings.
@ LL_DEBUG5
Log at debug level 5.
Definition: logging.h:44
@ LL_DEBUG1
Log at debug level 1.
Definition: logging.h:40
#define FREE(x)
Definition: memory.h:43
#define MIN(a, b)
Definition: memory.h:31
GUI present the user with a selectable list.
#define MENU_REDRAW_FULL
Redraw everything.
Definition: lib.h:60
void menu_queue_redraw(struct Menu *menu, MenuRedrawFlags redraw)
Queue a request for a redraw.
Definition: menu.c:178
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:154
MenuRedrawFlags menu_set_index(struct Menu *menu, int index)
Set the current selection in the Menu.
Definition: menu.c:168
Convenience wrapper for the library headers.
#define N_(a)
Definition: message.h:32
#define _(a)
Definition: message.h:28
bool notify_observer_remove(struct Notify *notify, const observer_t callback, const void *global_data)
Remove an observer from an object.
Definition: notify.c:228
bool notify_observer_add(struct Notify *notify, enum NotifyType type, observer_t callback, void *global_data)
Add an observer to an object.
Definition: notify.c:189
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:250
int mutt_str_asprintf(char **strp, const char *fmt,...)
Definition: string.c:1031
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:807
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
Definition: string.c:496
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:567
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:652
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:73
NeoMutt Logging.
void window_redraw(struct MuttWindow *win)
Reflow, recalc and repaint a tree of Windows.
Definition: mutt_window.c:605
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:523
@ WT_DLG_ALIAS
Alias Dialog, dlg_select_alias()
Definition: mutt_window.h:77
@ WT_STATUS_BAR
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:102
@ NT_WINDOW_DELETE
Window is about to be deleted.
Definition: mutt_window.h:205
Some miscellaneous functions.
@ NT_WINDOW
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:55
@ NT_CONFIG
Config has changed, NotifyConfig, EventConfig.
Definition: notify_type.h:43
@ NT_ALIAS
Alias has changed, NotifyAlias, EventAlias.
Definition: notify_type.h:37
const char * opcodes_get_name(int op)
Get the name of an opcode.
Definition: opcodes.c:46
All user-callable functions.
Match patterns to emails.
int mutt_pattern_alias_func(char *prompt, struct AliasMenuData *mdata, struct Menu *menu)
Perform some Pattern matching for Alias.
Definition: pattern.c:244
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:841
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:637
Convenience wrapper for the send headers.
int mutt_send_message(SendFlags flags, struct Email *e_templ, const char *tempfile, struct Mailbox *m, struct EmailList *el, struct ConfigSubset *sub)
Send an email.
Definition: send.c:2137
#define SEND_REVIEW_TO
Allow the user to edit the To field.
Definition: send.h:54
Sidebar functions.
Key value store.
#define NONULL(x)
Definition: string2.h:37
AliasView array wrapper with Pattern information -.
Definition: gui.h:52
char * limit
Limit being used.
Definition: gui.h:58
struct AliasViewArray ava
All Aliases/Queries.
Definition: gui.h:53
struct MuttWindow * sbar
Status Bar.
Definition: gui.h:59
struct Menu * menu
Menu.
Definition: gui.h:56
struct Buffer * query
Query string.
Definition: gui.h:57
char * title
Title for the status bar.
Definition: gui.h:60
struct ConfigSubset * sub
Config items.
Definition: gui.h:55
GUI data wrapping an Alias.
Definition: gui.h:36
bool is_visible
Is visible?
Definition: gui.h:43
struct Alias * alias
Alias.
Definition: gui.h:44
bool is_deleted
Is it deleted?
Definition: gui.h:42
bool is_tagged
Is it tagged?
Definition: gui.h:41
int num
Index number in list.
Definition: gui.h:37
A shortcut for an email address or addresses.
Definition: alias.h:34
char * comment
Free-form comment string.
Definition: alias.h:37
char * name
Short name.
Definition: alias.h:35
struct AddressList addr
List of Addresses the Alias expands to.
Definition: alias.h:36
String manipulation buffer.
Definition: buffer.h:34
A set of inherited config items.
Definition: subset.h:47
The envelope/body of an email.
Definition: email.h:37
struct Envelope * env
Envelope information.
Definition: email.h:66
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
An alias-change event.
Definition: alias.h:64
struct Alias * alias
Alias that changed.
Definition: alias.h:65
An Event that happened to a Window.
Definition: mutt_window.h:215
struct MuttWindow * win
Window that changed.
Definition: mutt_window.h:216
A mailbox.
Definition: mailbox.h:79
Mapping between user-readable string and a constant.
Definition: mapping.h:32
Definition: lib.h:70
struct MuttWindow * win
Window holding the Menu.
Definition: lib.h:77
void(* make_entry)(struct Menu *menu, char *buf, size_t buflen, int line)
Definition: lib.h:97
void(* mdata_free)(struct Menu *menu, void **ptr)
Definition: lib.h:152
int(* tag)(struct Menu *menu, int sel, int act)
Definition: lib.h:122
void * mdata
Private data.
Definition: lib.h:138
int max
Number of entries in the menu.
Definition: lib.h:72
bool custom_search
The menu implements its own non-Menusearch()-compatible search, trickle OP_SEARCH*.
Definition: lib.h:85
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
void * wdata
Private data.
Definition: mutt_window.h:145
struct Notify * notify
Notifications: NotifyWindow, EventWindow.
Definition: mutt_window.h:138
int(* recalc)(struct MuttWindow *win)
Definition: mutt_window.h:170
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct Notify * notify
Notifications handler.
Definition: neomutt.h:38
Data passed to a notification function.
Definition: observer.h:34
void * event_data
Data from notify_send()
Definition: observer.h:38
enum NotifyType event_type
Send: Event type, e.g. NT_ACCOUNT.
Definition: observer.h:36
int event_subtype
Send: Event subtype, e.g. NT_ACCOUNT_ADD.
Definition: observer.h:37
void * global_data
Data from notify_observer_add()
Definition: observer.h:39
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
@ MENU_ALIAS
Select an email address by its alias.
Definition: type.h:37