NeoMutt  2024-03-23-147-g885fbc
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
dlg_query.c
Go to the documentation of this file.
1
72#include "config.h"
73#include <stdbool.h>
74#include <stdio.h>
75#include <string.h>
76#include <sys/types.h>
77#include "mutt/lib.h"
78#include "address/lib.h"
79#include "config/lib.h"
80#include "email/lib.h"
81#include "core/lib.h"
82#include "gui/lib.h"
83#include "mutt.h"
84#include "lib.h"
85#include "editor/lib.h"
86#include "expando/lib.h"
87#include "history/lib.h"
88#include "key/lib.h"
89#include "menu/lib.h"
90#include "pattern/lib.h"
91#include "send/lib.h"
92#include "alias.h"
93#include "functions.h"
94#include "globals.h"
95#include "gui.h"
96#include "mutt_logging.h"
97
99
101static const struct Mapping QueryHelp[] = {
102 // clang-format off
103 { N_("Exit"), OP_EXIT },
104 { N_("Mail"), OP_MAIL },
105 { N_("New Query"), OP_QUERY },
106 { N_("Make Alias"), OP_CREATE_ALIAS },
107 { N_("Sort"), OP_SORT },
108 { N_("Rev-Sort"), OP_SORT_REVERSE },
109 { N_("Search"), OP_SEARCH },
110 { N_("Help"), OP_HELP },
111 { NULL, 0 },
112 // clang-format on
113};
114
121bool alias_to_addrlist(struct AddressList *al, struct Alias *alias)
122{
123 if (!al || !TAILQ_EMPTY(al) || !alias)
124 return false;
125
126 mutt_addrlist_copy(al, &alias->addr, false);
127 if (!TAILQ_EMPTY(al))
128 {
129 struct Address *first = TAILQ_FIRST(al);
130 struct Address *second = TAILQ_NEXT(first, entries);
131 if (!second && !first->personal)
132 {
133 first->personal = buf_new(alias->name);
134 }
135
136 mutt_addrlist_to_intl(al, NULL);
137 }
138
139 return true;
140}
141
145void query_a(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
146 int max_cols, struct Buffer *buf)
147{
148 const struct AliasView *av = data;
149 const struct Alias *alias = av->alias;
150
151 struct Buffer *addrs = buf_pool_get();
152 mutt_addrlist_write(&alias->addr, addrs, true);
153
154 buf_printf(buf, "<%s>", buf_string(addrs));
155}
156
160long query_c_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
161{
162 const struct AliasView *av = data;
163
164 return av->num + 1;
165}
166
170void query_e(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
171 int max_cols, struct Buffer *buf)
172{
173 const struct AliasView *av = data;
174 const struct Alias *alias = av->alias;
175
176 const char *s = alias->comment;
177 buf_strcpy(buf, s);
178}
179
183void query_n(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
184 int max_cols, struct Buffer *buf)
185{
186 const struct AliasView *av = data;
187 const struct Alias *alias = av->alias;
188
189 const char *s = alias->name;
190 buf_strcpy(buf, s);
191}
192
196long query_t_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
197{
198 const struct AliasView *av = data;
199 return av->is_tagged;
200}
201
205void query_t(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
206 int max_cols, struct Buffer *buf)
207{
208 const struct AliasView *av = data;
209
210 // NOTE(g0mb4): use $flag_chars?
211 const char *s = av->is_tagged ? "*" : " ";
212 buf_strcpy(buf, s);
213}
214
218void query_Y(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
219 int max_cols, struct Buffer *buf)
220{
221 const struct AliasView *av = data;
222
223 alias_tags_to_buffer(&av->alias->tags, buf);
224}
225
231static int query_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
232{
233 const struct AliasMenuData *mdata = menu->mdata;
234 const struct AliasViewArray *ava = &mdata->ava;
235 struct AliasView *av = ARRAY_GET(ava, line);
236
237 const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
238 if (c_arrow_cursor)
239 {
240 const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
241 max_cols -= (mutt_strwidth(c_arrow_string) + 1);
242 }
243
244 const struct Expando *c_query_format = cs_subset_expando(mdata->sub, "query_format");
245 return expando_render(c_query_format, QueryRenderData, av,
246 MUTT_FORMAT_ARROWCURSOR, max_cols, buf);
247}
248
252static int query_tag(struct Menu *menu, int sel, int act)
253{
254 const struct AliasMenuData *mdata = menu->mdata;
255 const struct AliasViewArray *ava = &mdata->ava;
256 struct AliasView *av = ARRAY_GET(ava, sel);
257
258 bool ot = av->is_tagged;
259
260 av->is_tagged = ((act >= 0) ? act : !av->is_tagged);
261 return av->is_tagged - ot;
262}
263
273int query_run(const char *s, bool verbose, struct AliasList *al, const struct ConfigSubset *sub)
274{
275 FILE *fp = NULL;
276 char *buf = NULL;
277 size_t buflen;
278 char *msg = NULL;
279 size_t msglen = 0;
280 char *tok = NULL;
281 char *next_tok = NULL;
282 struct Buffer *cmd = buf_pool_get();
283
284 const char *const c_query_command = cs_subset_string(sub, "query_command");
285 buf_file_expand_fmt_quote(cmd, c_query_command, s);
286
287 pid_t pid = filter_create(buf_string(cmd), NULL, &fp, NULL, EnvList);
288 if (pid < 0)
289 {
290 mutt_debug(LL_DEBUG1, "unable to fork command: %s\n", buf_string(cmd));
291 buf_pool_release(&cmd);
292 return -1;
293 }
294 buf_pool_release(&cmd);
295
296 if (verbose)
297 mutt_message(_("Waiting for response..."));
298
299 /* The query protocol first reads one NL-terminated line. If an error
300 * occurs, this is assumed to be an error message. Otherwise it's ignored. */
301 msg = mutt_file_read_line(msg, &msglen, fp, NULL, MUTT_RL_NO_FLAGS);
302 while ((buf = mutt_file_read_line(buf, &buflen, fp, NULL, MUTT_RL_NO_FLAGS)))
303 {
304 tok = buf;
305 next_tok = strchr(tok, '\t');
306 if (next_tok)
307 *next_tok++ = '\0';
308
309 if (*tok == '\0')
310 continue;
311
312 struct Alias *alias = alias_new();
313
314 mutt_addrlist_parse(&alias->addr, tok);
315
316 if (next_tok)
317 {
318 tok = next_tok;
319 next_tok = strchr(tok, '\t');
320 if (next_tok)
321 *next_tok++ = '\0';
322
323 alias->name = mutt_str_dup(tok);
324 parse_alias_comments(alias, next_tok);
325 }
326
327 TAILQ_INSERT_TAIL(al, alias, entries);
328 }
329
330 FREE(&buf);
331 mutt_file_fclose(&fp);
332 if (filter_wait(pid))
333 {
334 mutt_debug(LL_DEBUG1, "Error: %s\n", msg);
335 if (verbose)
336 mutt_error("%s", msg);
337 }
338 else
339 {
340 if (verbose)
341 mutt_message("%s", msg);
342 }
343 FREE(&msg);
344
345 return 0;
346}
347
352{
353 if (nc->event_type != NT_WINDOW)
354 return 0;
355 if (!nc->global_data || !nc->event_data)
356 return -1;
358 return 0;
359
360 struct MuttWindow *win_menu = nc->global_data;
361 struct EventWindow *ev_w = nc->event_data;
362 if (ev_w->win != win_menu)
363 return 0;
364
365 struct Menu *menu = win_menu->wdata;
366
369
370 mutt_debug(LL_DEBUG5, "window delete done\n");
371 return 0;
372}
373
380static struct MuttWindow *query_dialog_new(struct AliasMenuData *mdata, const char *query)
381{
383
384 struct Menu *menu = dlg->wdata;
385
387 menu->tag = query_tag;
388 menu->max = ARRAY_SIZE(&mdata->ava);
389 mdata->title = mutt_str_dup(_("Query"));
390 menu->mdata = mdata;
391 menu->mdata_free = NULL; // Menu doesn't own the data
392
393 struct MuttWindow *win_menu = menu->win;
394
395 // Override the Simple Dialog's recalc()
396 win_menu->recalc = alias_recalc;
397
398 char title[256] = { 0 };
399 snprintf(title, sizeof(title), "%s: %s", mdata->title, query);
400 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
401 sbar_set_title(sbar, title);
402
403 // NT_COLOR is handled by the SimpleDialog
406
407 return dlg;
408}
409
421static bool dlg_query(struct Buffer *buf, struct AliasMenuData *mdata)
422{
423 struct MuttWindow *dlg = query_dialog_new(mdata, buf_string(buf));
424 struct Menu *menu = dlg->wdata;
425 struct MuttWindow *win_sbar = window_find_child(dlg, WT_STATUS_BAR);
426 struct MuttWindow *win_menu = window_find_child(dlg, WT_MENU);
427 mdata->menu = menu;
428 mdata->sbar = win_sbar;
429 mdata->query = buf;
430
431 alias_array_sort(&mdata->ava, mdata->sub);
432
433 struct AliasView *avp = NULL;
434 ARRAY_FOREACH(avp, &mdata->ava)
435 {
436 avp->num = ARRAY_FOREACH_IDX;
437 }
438
439 struct MuttWindow *old_focus = window_set_focus(menu->win);
440 // ---------------------------------------------------------------------------
441 // Event Loop
442 int rc = 0;
443 int op = OP_NULL;
444 do
445 {
446 menu_tagging_dispatcher(menu->win, op);
447 window_redraw(NULL);
448
450 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
451 if (op < 0)
452 continue;
453 if (op == OP_NULL)
454 {
456 continue;
457 }
459
460 rc = alias_function_dispatcher(dlg, op);
461 if (rc == FR_UNKNOWN)
462 rc = menu_function_dispatcher(win_menu, op);
463 if (rc == FR_UNKNOWN)
464 rc = global_function_dispatcher(NULL, op);
465 } while ((rc != FR_DONE) && (rc != FR_CONTINUE));
466 // ---------------------------------------------------------------------------
467
468 window_set_focus(old_focus);
469 simple_dialog_free(&dlg);
470 window_redraw(NULL);
471 return (rc == FR_CONTINUE); // Was a selection made?
472}
473
480int query_complete(struct Buffer *buf, struct ConfigSubset *sub)
481{
482 struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
483 mdata.search_state = search_state_new();
484
485 struct AliasList al = TAILQ_HEAD_INITIALIZER(al);
486 const char *const c_query_command = cs_subset_string(sub, "query_command");
487 if (!c_query_command)
488 {
489 mutt_warning(_("Query command not defined"));
490 goto done;
491 }
492
493 query_run(buf_string(buf), true, &al, sub);
494 if (TAILQ_EMPTY(&al))
495 goto done;
496
497 mdata.al = &al;
498
499 struct Alias *a_first = TAILQ_FIRST(&al);
500 if (!TAILQ_NEXT(a_first, entries)) // only one response?
501 {
502 struct AddressList addr = TAILQ_HEAD_INITIALIZER(addr);
503 if (alias_to_addrlist(&addr, a_first))
504 {
506 buf_reset(buf);
507 mutt_addrlist_write(&addr, buf, false);
508 mutt_addrlist_clear(&addr);
510 }
511 goto done;
512 }
513
514 struct Alias *np = NULL;
515 TAILQ_FOREACH(np, mdata.al, entries)
516 {
517 alias_array_alias_add(&mdata.ava, np);
518 }
519
520 /* multiple results, choose from query menu */
521 if (!dlg_query(buf, &mdata))
522 goto done;
523
524 buf_reset(buf);
525 buf_alloc(buf, 8192);
526 bool first = true;
527 struct AliasView *avp = NULL;
528 ARRAY_FOREACH(avp, &mdata.ava)
529 {
530 if (!avp->is_tagged)
531 continue;
532
533 if (!first)
534 {
535 buf_addstr(buf, ", ");
536 }
537
538 first = false;
539 struct AddressList al_copy = TAILQ_HEAD_INITIALIZER(al_copy);
540 if (alias_to_addrlist(&al_copy, avp->alias))
541 {
542 mutt_addrlist_to_local(&al_copy);
543 mutt_addrlist_write(&al_copy, buf, false);
544 mutt_addrlist_clear(&al_copy);
545 }
546 }
547
548done:
549 ARRAY_FREE(&mdata.ava);
550 FREE(&mdata.title);
551 FREE(&mdata.limit);
553 aliaslist_clear(&al);
554 return 0;
555}
556
562void query_index(struct Mailbox *m, struct ConfigSubset *sub)
563{
564 const char *const c_query_command = cs_subset_string(sub, "query_command");
565 if (!c_query_command)
566 {
567 mutt_warning(_("Query command not defined"));
568 return;
569 }
570
571 struct AliasList al = TAILQ_HEAD_INITIALIZER(al);
572 struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
573 mdata.al = &al;
574 mdata.search_state = search_state_new();
575
576 struct Buffer *buf = buf_pool_get();
577 if ((mw_get_field(_("Query: "), buf, MUTT_COMP_NO_FLAGS, HC_OTHER, NULL, NULL) != 0) ||
578 buf_is_empty(buf))
579 {
580 goto done;
581 }
582
583 query_run(buf_string(buf), false, &al, sub);
584 if (TAILQ_EMPTY(&al))
585 goto done;
586
587 struct Alias *np = NULL;
588 TAILQ_FOREACH(np, mdata.al, entries)
589 {
590 alias_array_alias_add(&mdata.ava, np);
591 }
592
593 if (!dlg_query(buf, &mdata))
594 goto done;
595
596 // Prepare the "To:" field of a new email
597 struct Email *e = email_new();
598 e->env = mutt_env_new();
599
600 struct AliasView *avp = NULL;
601 ARRAY_FOREACH(avp, &mdata.ava)
602 {
603 if (!avp->is_tagged)
604 continue;
605
606 struct AddressList al_copy = TAILQ_HEAD_INITIALIZER(al_copy);
607 if (alias_to_addrlist(&al_copy, avp->alias))
608 {
609 mutt_addrlist_copy(&e->env->to, &al_copy, false);
610 mutt_addrlist_clear(&al_copy);
611 }
612 }
613
614 mutt_send_message(SEND_REVIEW_TO, e, NULL, m, NULL, sub);
615
616done:
617 ARRAY_FREE(&mdata.ava);
618 FREE(&mdata.title);
619 FREE(&mdata.limit);
621 aliaslist_clear(&al);
622 buf_pool_release(&buf);
623}
624
630const struct ExpandoRenderData QueryRenderData[] = {
631 // clang-format off
632 { ED_ALIAS, ED_ALI_ADDRESS, query_a, NULL },
634 { ED_ALIAS, ED_ALI_COMMENT, query_e, NULL },
635 { ED_ALIAS, ED_ALI_NAME, query_n, NULL },
637 { ED_ALIAS, ED_ALI_TAGS, query_Y, NULL },
638 { -1, -1, NULL, NULL },
639 // clang-format on
640};
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:765
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1460
int mutt_addrlist_to_local(struct AddressList *al)
Convert an Address list from Punycode.
Definition: address.c:1378
size_t mutt_addrlist_write(const struct AddressList *al, struct Buffer *buf, bool display)
Write an Address to a buffer.
Definition: address.c:1206
int mutt_addrlist_parse(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:480
int mutt_addrlist_to_intl(struct AddressList *al, char **err)
Convert an Address list to Punycode.
Definition: address.c:1293
Email Address Handling.
void parse_alias_comments(struct Alias *alias, const char *com)
Parse the alias/query comment field.
Definition: commands.c:95
void alias_tags_to_buffer(struct TagList *tl, struct Buffer *buf)
Write a comma-separated list of tags to a Buffer.
Definition: commands.c:49
void alias_array_sort(struct AliasViewArray *ava, const struct ConfigSubset *sub)
Sort and reindex an AliasViewArray.
Definition: sort.c:168
struct Alias * alias_new(void)
Create a new Alias.
Definition: alias.c:660
void aliaslist_clear(struct AliasList *al)
Empty a List of Aliases.
Definition: alias.c:697
Representation of a single alias to an email address.
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:212
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:87
#define ARRAY_FREE(head)
Release all memory.
Definition: array.h:204
#define ARRAY_GET(head, idx)
Return the element at index.
Definition: array.h:109
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
Definition: array.h:58
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:75
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:290
struct Buffer * buf_new(const char *str)
Allocate a new Buffer.
Definition: buffer.c:303
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:225
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:394
void buf_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition: buffer.c:336
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
const struct Expando * cs_subset_expando(const struct ConfigSubset *sub, const char *name)
Get an Expando config item by name.
Definition: config_type.c:358
Convenience wrapper for the config headers.
Convenience wrapper for the core headers.
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:443
@ 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 QueryHelp[]
Help Bar for the Address Query dialog.
Definition: dlg_query.c:101
int query_run(const char *s, bool verbose, struct AliasList *al, const struct ConfigSubset *sub)
Run an external program to find Addresses.
Definition: dlg_query.c:273
bool alias_to_addrlist(struct AddressList *al, struct Alias *alias)
Turn an Alias into an AddressList.
Definition: dlg_query.c:121
int query_complete(struct Buffer *buf, struct ConfigSubset *sub)
Perform auto-complete using an Address Query.
Definition: dlg_query.c:480
const struct ExpandoRenderData QueryRenderData[]
Callbacks for Query Expandos.
Definition: dlg_query.c:98
static struct MuttWindow * query_dialog_new(struct AliasMenuData *mdata, const char *query)
Create an Query Selection Dialog.
Definition: dlg_query.c:380
void query_index(struct Mailbox *m, struct ConfigSubset *sub)
Perform an Alias Query and display the results.
Definition: dlg_query.c:562
@ ED_ALIAS
Alias ED_ALI_ ExpandoDataAlias.
Definition: domain.h:35
Edit a string.
struct Email * email_new(void)
Create a new Email.
Definition: email.c:80
Structs that make up an email.
struct Envelope * mutt_env_new(void)
Create a new Envelope.
Definition: envelope.c:46
Parse Expando string.
int expando_render(const struct Expando *exp, const struct ExpandoRenderData *rdata, void *data, MuttFormatFlags flags, int max_cols, struct Buffer *buf)
Render an Expando + data into a string.
Definition: expando.c:110
char * mutt_file_read_line(char *line, size_t *size, FILE *fp, int *line_num, ReadLineFlags flags)
Read a line from a file.
Definition: file.c:805
void buf_file_expand_fmt_quote(struct Buffer *dest, const char *fmt, const char *src)
Replace s in a string with a filename.
Definition: file.c:1453
#define mutt_file_fclose(FP)
Definition: file.h:147
#define MUTT_RL_NO_FLAGS
No flags are set.
Definition: file.h:40
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:220
pid_t filter_create(const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err, char **envlist)
Set up filter program.
Definition: filter.c:209
int km_dokey(enum MenuType mtype, GetChFlags flags)
Determine what a keypress should do.
Definition: get.c:463
void km_error_key(enum MenuType mtype)
Handle an unbound key sequence.
Definition: get.c:293
char ** EnvList
Private copy of the environment variables.
Definition: globals.c:78
int menu_tagging_dispatcher(struct MuttWindow *win, int op)
Perform tagging operations on the Menu - Implements function_dispatcher_t -.
Definition: tagging.c:230
int global_function_dispatcher(struct MuttWindow *win, int op)
Perform a Global function - Implements function_dispatcher_t -.
Definition: global.c:172
int menu_function_dispatcher(struct MuttWindow *win, int op)
Perform a Menu function - Implements function_dispatcher_t -.
Definition: functions.c:318
int alias_function_dispatcher(struct MuttWindow *win, int op)
Perform a Alias function - Implements function_dispatcher_t -.
Definition: functions.c:418
long query_t_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
Query: Tagged char - Implements ExpandoRenderData::get_number() -.
Definition: dlg_query.c:196
long query_c_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
Query: Index number - Implements ExpandoRenderData::get_number() -.
Definition: dlg_query.c:160
void query_a(const struct ExpandoNode *node, void *data, MuttFormatFlags flags, int max_cols, struct Buffer *buf)
Query: Address - Implements ExpandoRenderData::get_string() -.
Definition: dlg_query.c:145
void query_Y(const struct ExpandoNode *node, void *data, MuttFormatFlags flags, int max_cols, struct Buffer *buf)
Query: Tags - Implements ExpandoRenderData::get_string() -.
Definition: dlg_query.c:218
void query_t(const struct ExpandoNode *node, void *data, MuttFormatFlags flags, int max_cols, struct Buffer *buf)
Query: Tagged char - Implements ExpandoRenderData::get_string() -.
Definition: dlg_query.c:205
void query_n(const struct ExpandoNode *node, void *data, MuttFormatFlags flags, int max_cols, struct Buffer *buf)
Query: Name - Implements ExpandoRenderData::get_string() -.
Definition: dlg_query.c:183
void query_e(const struct ExpandoNode *node, void *data, MuttFormatFlags flags, int max_cols, struct Buffer *buf)
Query: Extra information - Implements ExpandoRenderData::get_string() -.
Definition: dlg_query.c:170
static bool dlg_query(struct Buffer *buf, struct AliasMenuData *mdata)
Get the user to enter an Address Query -.
Definition: dlg_query.c:421
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 -.
Definition: window.c:274
#define mutt_warning(...)
Definition: logging2.h:90
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_message(...)
Definition: logging2.h:91
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
static int query_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format an Alias for the Menu - Implements Menu::make_entry() -.
Definition: dlg_query.c:231
static int query_tag(struct Menu *menu, int sel, int act)
Tag an entry in the Query Menu - Implements Menu::tag() -.
Definition: dlg_query.c:252
static int query_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_query.c:351
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:168
struct MuttWindow * simple_dialog_new(enum MenuType mtype, enum WindowType wtype, const struct Mapping *help_data)
Create a simple index Dialog.
Definition: simple.c:132
Shared code for the Alias and Query Dialogs.
@ ED_ALI_NUMBER
AliasView.num.
Definition: gui.h:77
@ ED_ALI_NAME
Alias.name.
Definition: gui.h:76
@ ED_ALI_ADDRESS
Alias.addr.
Definition: gui.h:73
@ ED_ALI_COMMENT
Alias.comment.
Definition: gui.h:74
@ ED_ALI_TAGGED
AliasView.tagged.
Definition: gui.h:78
@ ED_ALI_TAGS
Alias.tags.
Definition: gui.h:79
Read/write command history from/to a file.
@ HC_OTHER
Miscellaneous strings.
Definition: lib.h:56
Manage keymappings.
#define GETCH_NO_FLAGS
No flags are set.
Definition: lib.h:51
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
#define FREE(x)
Definition: memory.h:45
GUI present the user with a selectable list.
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:230
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:191
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
Many unsorted constants and some structs.
#define MUTT_COMP_NO_FLAGS
No flags are set.
Definition: mutt.h:56
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
NeoMutt Logging.
void window_redraw(struct MuttWindow *win)
Reflow, recalc and repaint a tree of Windows.
Definition: mutt_window.c:634
struct MuttWindow * window_set_focus(struct MuttWindow *win)
Set the Window focus.
Definition: mutt_window.c:684
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:533
@ WT_DLG_QUERY
Query Dialog, dlg_query()
Definition: mutt_window.h:90
@ WT_STATUS_BAR
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:102
@ WT_MENU
An Window containing a Menu.
Definition: mutt_window.h:98
@ NT_WINDOW_DELETE
Window is about to be deleted.
Definition: mutt_window.h:229
@ NT_WINDOW
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:57
@ NT_CONFIG
Config has changed, NotifyConfig, EventConfig.
Definition: notify_type.h:43
const char * opcodes_get_name(int op)
Get the name of an opcode.
Definition: opcodes.c:48
Match patterns to emails.
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:809
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define TAILQ_NEXT(elm, field)
Definition: queue.h:832
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:637
#define TAILQ_EMPTY(head)
Definition: queue.h:721
#define MUTT_FORMAT_ARROWCURSOR
Reserve space for arrow_cursor.
Definition: render.h:37
uint8_t MuttFormatFlags
Flags for expando_render(), e.g. MUTT_FORMAT_FORCESUBJ.
Definition: render.h:32
void sbar_set_title(struct MuttWindow *win, const char *title)
Set the title for the Simple Bar.
Definition: sbar.c:227
void search_state_free(struct SearchState **ptr)
Free a SearchState.
Definition: search_state.c:51
struct SearchState * search_state_new(void)
Create a new SearchState.
Definition: search_state.c:39
Convenience wrapper for the send headers.
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.
Definition: send.c:2120
#define SEND_REVIEW_TO
Allow the user to edit the To field.
Definition: send.h:56
Sidebar functions.
Key value store.
An email address.
Definition: address.h:36
struct Buffer * personal
Real name of address.
Definition: address.h:37
AliasView array wrapper with Pattern information -.
Definition: gui.h:54
char * limit
Limit being used.
Definition: gui.h:60
struct AliasViewArray ava
All Aliases/Queries.
Definition: gui.h:55
struct SearchState * search_state
State of the current search.
Definition: gui.h:63
struct MuttWindow * sbar
Status Bar.
Definition: gui.h:61
struct Menu * menu
Menu.
Definition: gui.h:58
struct Buffer * query
Query string.
Definition: gui.h:59
char * title
Title for the status bar.
Definition: gui.h:62
struct AliasList * al
Alias data.
Definition: gui.h:56
struct ConfigSubset * sub
Config items.
Definition: gui.h:57
GUI data wrapping an Alias.
Definition: gui.h:38
struct Alias * alias
Alias.
Definition: gui.h:46
bool is_tagged
Is it tagged?
Definition: gui.h:43
int num
Index number in list.
Definition: gui.h:39
A shortcut for an email address or addresses.
Definition: alias.h:35
struct TagList tags
Tags.
Definition: alias.h:39
char * comment
Free-form comment string.
Definition: alias.h:38
char * name
Short name.
Definition: alias.h:36
struct AddressList addr
List of Addresses the Alias expands to.
Definition: alias.h:37
String manipulation buffer.
Definition: buffer.h:36
char * data
Pointer to data.
Definition: buffer.h:37
A set of inherited config items.
Definition: subset.h:47
struct Notify * notify
Notifications: NotifyConfig, EventConfig.
Definition: subset.h:52
The envelope/body of an email.
Definition: email.h:39
struct Envelope * env
Envelope information.
Definition: email.h:68
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
An Event that happened to a Window.
Definition: mutt_window.h:239
struct MuttWindow * win
Window that changed.
Definition: mutt_window.h:240
Basic Expando Node.
Definition: node.h:67
Parsed Expando trees.
Definition: expando.h:41
A mailbox.
Definition: mailbox.h:79
Mapping between user-readable string and a constant.
Definition: mapping.h:33
Definition: lib.h:79
struct MuttWindow * win
Window holding the Menu.
Definition: lib.h:86
void(* mdata_free)(struct Menu *menu, void **ptr)
Definition: lib.h:161
int(* tag)(struct Menu *menu, int sel, int act)
Definition: lib.h:131
int(* make_entry)(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Definition: lib.h:106
struct ConfigSubset * sub
Inherited config items.
Definition: lib.h:87
void * mdata
Private data.
Definition: lib.h:147
int max
Number of entries in the menu.
Definition: lib.h:81
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:173
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
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
@ MENU_QUERY
Select from results of external query.
Definition: type.h:58