NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
dlg_index.c
Go to the documentation of this file.
1
60#include "config.h"
61#include <stdbool.h>
62#include <stdio.h>
63#include <string.h>
64#include "private.h"
65#include "mutt/lib.h"
66#include "config/lib.h"
67#include "email/lib.h"
68#include "core/lib.h"
69#include "conn/lib.h"
70#include "gui/lib.h"
71#include "lib.h"
72#include "color/lib.h"
73#include "expando/lib.h"
74#include "key/lib.h"
75#include "menu/lib.h"
76#include "nntp/lib.h"
77#include "pager/lib.h"
78#include "pattern/lib.h"
79#include "sidebar/lib.h"
80#include "functions.h"
81#include "globals.h"
82#include "hdrline.h"
83#include "hook.h"
84#include "mutt_logging.h"
85#include "mutt_mailbox.h"
86#include "mutt_thread.h"
87#include "mview.h"
88#include "mx.h"
89#include "nntp/adata.h"
90#include "private_data.h"
91#include "protos.h"
92#include "shared_data.h"
93#include "sort.h"
94#include "status.h"
95#ifdef USE_NOTMUCH
96#include "notmuch/lib.h"
97#endif
98#ifdef USE_INOTIFY
99#include "monitor.h"
100#endif
101
103static const struct Mapping IndexHelp[] = {
104 // clang-format off
105 { N_("Quit"), OP_QUIT },
106 { N_("Del"), OP_DELETE },
107 { N_("Undel"), OP_UNDELETE },
108 { N_("Save"), OP_SAVE },
109 { N_("Mail"), OP_MAIL },
110 { N_("Reply"), OP_REPLY },
111 { N_("Group"), OP_GROUP_REPLY },
112 { N_("Help"), OP_HELP },
113 { NULL, 0 },
114 // clang-format on
115};
116
118const struct Mapping IndexNewsHelp[] = {
119 // clang-format off
120 { N_("Quit"), OP_QUIT },
121 { N_("Del"), OP_DELETE },
122 { N_("Undel"), OP_UNDELETE },
123 { N_("Save"), OP_SAVE },
124 { N_("Post"), OP_POST },
125 { N_("Followup"), OP_FOLLOWUP },
126 { N_("Catchup"), OP_CATCHUP },
127 { N_("Help"), OP_HELP },
128 { NULL, 0 },
129 // clang-format on
130};
131
139bool check_acl(struct Mailbox *m, AclFlags acl, const char *msg)
140{
141 if (!m)
142 return false;
143
144 if (!(m->rights & acl))
145 {
146 /* L10N: %s is one of the CHECK_ACL entries below. */
147 mutt_error(_("%s: Operation not permitted by ACL"), msg);
148 return false;
149 }
150
151 return true;
152}
153
166void collapse_all(struct MailboxView *mv, struct Menu *menu, int toggle)
167{
168 if (!mv || !mv->mailbox || (mv->mailbox->msg_count == 0) || !menu)
169 return;
170
171 struct Email *e_cur = mutt_get_virt_email(mv->mailbox, menu_get_index(menu));
172 if (!e_cur)
173 return;
174
175 int final;
176
177 /* Figure out what the current message would be after folding / unfolding,
178 * so that we can restore the cursor in a sane way afterwards. */
179 if (e_cur->collapsed && toggle)
180 final = mutt_uncollapse_thread(e_cur);
181 else if (mutt_thread_can_collapse(e_cur))
182 final = mutt_collapse_thread(e_cur);
183 else
184 final = e_cur->vnum;
185
186 if (final == -1)
187 return;
188
189 struct Email *base = mutt_get_virt_email(mv->mailbox, final);
190 if (!base)
191 return;
192
193 /* Iterate all threads, perform collapse/uncollapse as needed */
194 mv->collapsed = toggle ? !mv->collapsed : true;
196
197 /* Restore the cursor */
199 menu->max = mv->mailbox->vcount;
200 for (int i = 0; i < mv->mailbox->vcount; i++)
201 {
202 struct Email *e = mutt_get_virt_email(mv->mailbox, i);
203 if (!e)
204 break;
205 if (e->index == base->index)
206 {
207 menu_set_index(menu, i);
208 break;
209 }
210 }
211
213}
214
220static void uncollapse_thread(struct MailboxView *mv, int index)
221{
222 if (!mv || !mv->mailbox)
223 return;
224
225 struct Mailbox *m = mv->mailbox;
226 struct Email *e = mutt_get_virt_email(m, index);
227 if (e && e->collapsed)
228 {
230 mutt_set_vnum(m);
231 }
232}
233
242int find_next_undeleted(struct MailboxView *mv, int msgno, bool uncollapse)
243{
244 if (!mv || !mv->mailbox)
245 return -1;
246
247 struct Mailbox *m = mv->mailbox;
248
249 int index = -1;
250 for (int i = msgno + 1; i < m->vcount; i++)
251 {
252 struct Email *e = mutt_get_virt_email(m, i);
253 if (!e)
254 continue;
255 if (!e->deleted)
256 {
257 index = i;
258 break;
259 }
260 }
261
262 if (uncollapse)
264
265 return index;
266}
267
276int find_previous_undeleted(struct MailboxView *mv, int msgno, bool uncollapse)
277{
278 if (!mv || !mv->mailbox)
279 return -1;
280
281 struct Mailbox *m = mv->mailbox;
282
283 int index = -1;
284 for (int i = msgno - 1; i >= 0; i--)
285 {
286 struct Email *e = mutt_get_virt_email(m, i);
287 if (!e)
288 continue;
289 if (!e->deleted)
290 {
291 index = i;
292 break;
293 }
294 }
295
296 if (uncollapse)
298
299 return index;
300}
301
311{
312 if (!mv)
313 return 0;
314
315 struct Mailbox *m = mv->mailbox;
316 if (!m || (m->msg_count == 0))
317 return 0;
318
319 int old = -1;
320 for (int i = 0; i < m->vcount; i++)
321 {
322 struct Email *e = mutt_get_virt_email(m, i);
323 if (!e)
324 continue;
325 if (!e->read && !e->deleted)
326 {
327 if (!e->old)
328 return i;
329 if (old == -1)
330 old = i;
331 }
332 }
333 if (old != -1)
334 return old;
335
336 /* If `$use_threads` is not threaded and `$sort` is reverse, the latest
337 * message is first. Otherwise, the latest message is first if exactly
338 * one of `$use_threads` and `$sort` are reverse.
339 */
340 enum SortType c_sort = cs_subset_sort(m->sub, "sort");
341 if ((c_sort & SORT_MASK) == SORT_THREADS)
342 c_sort = cs_subset_sort(m->sub, "sort_aux");
343 bool reverse = false;
344 switch (mutt_thread_style())
345 {
346 case UT_FLAT:
347 reverse = c_sort & SORT_REVERSE;
348 break;
349 case UT_THREADS:
350 reverse = c_sort & SORT_REVERSE;
351 break;
352 case UT_REVERSE:
353 reverse = !(c_sort & SORT_REVERSE);
354 break;
355 default:
356 ASSERT(false);
357 }
358
359 if (reverse || (m->vcount == 0))
360 return 0;
361
362 return m->vcount - 1;
363}
364
370void resort_index(struct MailboxView *mv, struct Menu *menu)
371{
372 if (!mv || !mv->mailbox || !menu)
373 return;
374
375 struct Mailbox *m = mv->mailbox;
376 const int old_index = menu_get_index(menu);
377 struct Email *e_cur = mutt_get_virt_email(m, old_index);
378
379 int new_index = -1;
380 mutt_sort_headers(mv, false);
381
382 /* Restore the current message */
383 for (int i = 0; i < m->vcount; i++)
384 {
385 struct Email *e = mutt_get_virt_email(m, i);
386 if (!e)
387 continue;
388 if (e == e_cur)
389 {
390 new_index = i;
391 break;
392 }
393 }
394
395 if (mutt_using_threads() && (old_index < 0))
396 new_index = mutt_parent_message(e_cur, false);
397
398 if (old_index < 0)
399 new_index = find_first_message(mv);
400
401 menu->max = m->vcount;
402 menu_set_index(menu, new_index);
404}
405
412static void update_index_threaded(struct MailboxView *mv, enum MxStatus check, int oldcount)
413{
414 struct Email **save_new = NULL;
415 const bool lmt = mview_has_limit(mv);
416
417 struct Mailbox *m = mv->mailbox;
418 int num_new = MAX(0, m->msg_count - oldcount);
419
420 const bool c_uncollapse_new = cs_subset_bool(m->sub, "uncollapse_new");
421 /* save the list of new messages */
422 if ((check != MX_STATUS_REOPENED) && (oldcount > 0) &&
423 (lmt || c_uncollapse_new) && (num_new > 0))
424 {
425 save_new = mutt_mem_malloc(num_new * sizeof(struct Email *));
426 for (int i = oldcount; i < m->msg_count; i++)
427 save_new[i - oldcount] = m->emails[i];
428 }
429
430 /* Sort first to thread the new messages, because some patterns
431 * require the threading information.
432 *
433 * If the mailbox was reopened, need to rethread from scratch. */
435
436 if (lmt)
437 {
438 for (int i = 0; i < m->msg_count; i++)
439 {
440 struct Email *e = m->emails[i];
441
442 if ((e->limit_visited && e->visible) ||
444 MUTT_MATCH_FULL_ADDRESS, m, e, NULL))
445 {
446 /* vnum will get properly set by mutt_set_vnum(), which
447 * is called by mutt_sort_headers() just below. */
448 e->vnum = 1;
449 e->visible = true;
450 }
451 else
452 {
453 e->vnum = -1;
454 e->visible = false;
455 }
456
457 // mark email as visited so we don't re-apply the pattern next time
458 e->limit_visited = true;
459 }
460 /* Need a second sort to set virtual numbers and redraw the tree */
461 mutt_sort_headers(mv, false);
462 }
463
464 /* uncollapse threads with new mail */
465 if (c_uncollapse_new)
466 {
467 if (check == MX_STATUS_REOPENED)
468 {
469 mv->collapsed = false;
471 mutt_set_vnum(m);
472 }
473 else if (oldcount > 0)
474 {
475 for (int j = 0; j < num_new; j++)
476 {
477 if (save_new[j]->visible)
478 {
479 mutt_uncollapse_thread(save_new[j]);
480 }
481 }
482 mutt_set_vnum(m);
483 }
484 }
485
486 FREE(&save_new);
487}
488
494static void update_index_unthreaded(struct MailboxView *mv, enum MxStatus check)
495{
496 /* We are in a limited view. Check if the new message(s) satisfy
497 * the limit criteria. If they do, set their virtual msgno so that
498 * they will be visible in the limited view */
499 if (mview_has_limit(mv))
500 {
501 int padding = mx_msg_padding_size(mv->mailbox);
502 mv->mailbox->vcount = mv->vsize = 0;
503 for (int i = 0; i < mv->mailbox->msg_count; i++)
504 {
505 struct Email *e = mv->mailbox->emails[i];
506 if (!e)
507 break;
508
509 if ((e->limit_visited && e->visible) ||
511 MUTT_MATCH_FULL_ADDRESS, mv->mailbox, e, NULL))
512 {
514 e->vnum = mv->mailbox->vcount;
515 mv->mailbox->v2r[mv->mailbox->vcount] = i;
516 e->visible = true;
517 mv->mailbox->vcount++;
518 struct Body *b = e->body;
519 mv->vsize += b->length + b->offset - b->hdr_offset + padding;
520 }
521 else
522 {
523 e->visible = false;
524 }
525
526 // mark email as visited so we don't re-apply the pattern next time
527 e->limit_visited = true;
528 }
529 }
530
531 /* if the mailbox was reopened, need to rethread from scratch */
533}
534
543void update_index(struct Menu *menu, struct MailboxView *mv, enum MxStatus check,
544 int oldcount, const struct IndexSharedData *shared)
545{
546 if (!menu || !mv)
547 return;
548
549 struct Mailbox *m = mv->mailbox;
550 if (mutt_using_threads())
551 update_index_threaded(mv, check, oldcount);
552 else
553 update_index_unthreaded(mv, check);
554
555 menu->max = m->vcount;
556 const int old_index = menu_get_index(menu);
557 int index = -1;
558 if (oldcount)
559 {
560 /* restore the current message to the message it was pointing to */
561 for (int i = 0; i < m->vcount; i++)
562 {
563 struct Email *e = mutt_get_virt_email(m, i);
564 if (!e)
565 continue;
566 if (index_shared_data_is_cur_email(shared, e))
567 {
568 index = i;
569 break;
570 }
571 }
572 }
573
574 if (index < 0)
575 {
576 index = (old_index < m->vcount) ? old_index : find_first_message(mv);
577 }
578 menu_set_index(menu, index);
579}
580
587{
588 if (nc->event_type != NT_MAILBOX)
589 return 0;
590 if (!nc->global_data)
591 return -1;
593 return 0;
594
595 struct Mailbox **ptr = nc->global_data;
596 if (!*ptr)
597 return 0;
598
599 *ptr = NULL;
600 mutt_debug(LL_DEBUG5, "mailbox done\n");
601 return 0;
602}
603
612void change_folder_mailbox(struct Menu *menu, struct Mailbox *m, int *oldcount,
613 struct IndexSharedData *shared, bool read_only)
614{
615 if (!m)
616 return;
617
618 /* keepalive failure in mutt_enter_fname may kill connection. */
619 if (shared->mailbox && (buf_is_empty(&shared->mailbox->pathbuf)))
620 {
621 mview_free(&shared->mailbox_view);
622 mailbox_free(&shared->mailbox);
623 }
624
625 if (shared->mailbox)
626 {
627 char *new_last_folder = NULL;
628#ifdef USE_INOTIFY
629 int monitor_remove_rc = mutt_monitor_remove(NULL);
630#endif
631 if (shared->mailbox->compress_info && (shared->mailbox->realpath[0] != '\0'))
632 new_last_folder = mutt_str_dup(shared->mailbox->realpath);
633 else
634 new_last_folder = mutt_str_dup(mailbox_path(shared->mailbox));
635 *oldcount = shared->mailbox->msg_count;
636
637 const enum MxStatus check = mx_mbox_close(shared->mailbox);
638 if (check == MX_STATUS_OK)
639 {
640 mview_free(&shared->mailbox_view);
641 if (shared->mailbox != m)
642 {
643 mailbox_free(&shared->mailbox);
644 }
645 }
646 else
647 {
648#ifdef USE_INOTIFY
649 if (monitor_remove_rc == 0)
650 mutt_monitor_add(NULL);
651#endif
652 if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
653 update_index(menu, shared->mailbox_view, check, *oldcount, shared);
654
655 FREE(&new_last_folder);
658 return;
659 }
661 LastFolder = new_last_folder;
662 }
664
665 /* If the `folder-hook` were to call `unmailboxes`, then the Mailbox (`m`)
666 * could be deleted, leaving `m` dangling. */
667 // TODO: Refactor this function to avoid the need for an observer
669 char *dup_path = mutt_str_dup(mailbox_path(m));
670 char *dup_name = mutt_str_dup(m->name);
671
672 mutt_folder_hook(dup_path, dup_name);
673 if (m)
674 {
675 /* `m` is still valid, but we won't need the observer again before the end
676 * of the function. */
678 }
679 else
680 {
681 // Recreate the Mailbox as the folder-hook might have invoked `mailboxes`
682 // and/or `unmailboxes`.
683 m = mx_path_resolve(dup_path);
684 }
685
686 FREE(&dup_path);
687 FREE(&dup_name);
688
689 if (!m)
690 return;
691
692 const OpenMailboxFlags flags = read_only ? MUTT_READONLY : MUTT_OPEN_NO_FLAGS;
693 if (mx_mbox_open(m, flags))
694 {
695 struct MailboxView *mv = mview_new(m, NeoMutt->notify);
696 index_shared_data_set_mview(shared, mv);
697
698 menu->max = m->msg_count;
700#ifdef USE_INOTIFY
701 mutt_monitor_add(NULL);
702#endif
703 }
704 else
705 {
706 index_shared_data_set_mview(shared, NULL);
708 }
709
710 const bool c_collapse_all = cs_subset_bool(shared->sub, "collapse_all");
711 if (mutt_using_threads() && c_collapse_all)
712 collapse_all(shared->mailbox_view, menu, 0);
713
715 /* force the mailbox check after we have changed the folder */
716 struct EventMailbox ev_m = { shared->mailbox };
720}
721
722#ifdef USE_NOTMUCH
733struct Mailbox *change_folder_notmuch(struct Menu *menu, char *buf, int buflen, int *oldcount,
734 struct IndexSharedData *shared, bool read_only)
735{
736 if (!nm_url_from_query(NULL, buf, buflen))
737 {
738 mutt_message(_("Failed to create query, aborting"));
739 return NULL;
740 }
741
742 struct Mailbox *m_query = mx_path_resolve(buf);
743 change_folder_mailbox(menu, m_query, oldcount, shared, read_only);
744 if (!shared->mailbox_view)
745 mailbox_free(&m_query);
746 return m_query;
747}
748#endif
749
758void change_folder_string(struct Menu *menu, struct Buffer *buf, int *oldcount,
759 struct IndexSharedData *shared, bool read_only)
760{
761 if (OptNews)
762 {
763 OptNews = false;
765 }
766 else
767 {
768 const char *const c_folder = cs_subset_string(shared->sub, "folder");
769 mx_path_canon(buf, c_folder, NULL);
770 }
771
773 if ((type == MUTT_MAILBOX_ERROR) || (type == MUTT_UNKNOWN))
774 {
775 // Look for a Mailbox by its description, before failing
776 struct Mailbox *m = mailbox_find_name(buf_string(buf));
777 if (m)
778 {
779 change_folder_mailbox(menu, m, oldcount, shared, read_only);
780 }
781 else
782 {
783 mutt_error(_("%s is not a mailbox"), buf_string(buf));
784 }
785 return;
786 }
787
788 struct Mailbox *m = mx_path_resolve(buf_string(buf));
789 change_folder_mailbox(menu, m, oldcount, shared, read_only);
790}
791
797int index_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
798{
799 if (!menu || !menu->mdata)
800 return 0;
801
802 struct IndexPrivateData *priv = menu->mdata;
803 struct IndexSharedData *shared = priv->shared;
804 struct Mailbox *m = shared->mailbox;
805 if (!shared->mailbox_view)
806 menu->current = -1;
807
808 if (!m || (line < 0) || (line >= m->email_max))
809 return 0;
810
811 struct Email *e = mutt_get_virt_email(m, line);
812 if (!e)
813 return 0;
814
816 struct MuttThread *tmp = NULL;
817
818 const enum UseThreads c_threads = mutt_thread_style();
819 if ((c_threads > UT_FLAT) && e->tree && e->thread)
820 {
821 flags |= MUTT_FORMAT_TREE; /* display the thread tree */
822 if (e->display_subject)
823 {
824 flags |= MUTT_FORMAT_FORCESUBJ;
825 }
826 else
827 {
828 const bool reverse = c_threads == UT_REVERSE;
829 int edgemsgno;
830 if (reverse)
831 {
832 if (menu->top + menu->page_len > menu->max)
833 edgemsgno = m->v2r[menu->max - 1];
834 else
835 edgemsgno = m->v2r[menu->top + menu->page_len - 1];
836 }
837 else
838 {
839 edgemsgno = m->v2r[menu->top];
840 }
841
842 for (tmp = e->thread->parent; tmp; tmp = tmp->parent)
843 {
844 if (!tmp->message)
845 continue;
846
847 /* if no ancestor is visible on current screen, provisionally force
848 * subject... */
849 if (reverse ? (tmp->message->msgno > edgemsgno) : (tmp->message->msgno < edgemsgno))
850 {
851 flags |= MUTT_FORMAT_FORCESUBJ;
852 break;
853 }
854 else if (tmp->message->vnum >= 0)
855 {
856 break;
857 }
858 }
859 if (flags & MUTT_FORMAT_FORCESUBJ)
860 {
861 for (tmp = e->thread->prev; tmp; tmp = tmp->prev)
862 {
863 if (!tmp->message)
864 continue;
865
866 /* ...but if a previous sibling is available, don't force it */
867 if (reverse ? (tmp->message->msgno > edgemsgno) : (tmp->message->msgno < edgemsgno))
868 {
869 break;
870 }
871 else if (tmp->message->vnum >= 0)
872 {
873 flags &= ~MUTT_FORMAT_FORCESUBJ;
874 break;
875 }
876 }
877 }
878 }
879 }
880
881 const struct Expando *c_index_format = cs_subset_expando(shared->sub, "index_format");
882 int msg_in_pager = shared->mailbox_view ? shared->mailbox_view->msg_in_pager : 0;
883
884 const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
885 if (c_arrow_cursor)
886 {
887 const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
888 max_cols -= (mutt_strwidth(c_arrow_string) + 1);
889 }
890
891 return mutt_make_string(buf, max_cols, c_index_format, m, msg_in_pager, e, flags, NULL);
892}
893
897const struct AttrColor *index_color(struct Menu *menu, int line)
898{
899 struct IndexPrivateData *priv = menu->mdata;
900 struct IndexSharedData *shared = priv->shared;
901 struct Mailbox *m = shared->mailbox;
902 if (!m || (line < 0))
903 return NULL;
904
905 struct Email *e = mutt_get_virt_email(m, line);
906 if (!e)
907 return NULL;
908
909 if (e->attr_color)
910 return e->attr_color;
911
913 return e->attr_color;
914}
915
929void mutt_draw_statusline(struct MuttWindow *win, int max_cols, const char *buf, size_t buflen)
930{
931 if (!buf || !stdscr)
932 return;
933
934 size_t i = 0;
935 size_t offset = 0;
936 bool found = false;
937 size_t chunks = 0;
938 size_t len = 0;
939
943 struct StatusSyntax
944 {
945 const struct AttrColor *attr_color;
946 int first;
947 int last;
948 } *syntax = NULL;
949
952 do
953 {
954 struct RegexColor *cl = NULL;
955 found = false;
956
957 if (!buf[offset])
958 break;
959
960 /* loop through each "color status regex" */
962 {
963 regmatch_t pmatch[cl->match + 1];
964 memset(pmatch, 0, (cl->match + 1) * sizeof(regmatch_t));
965
966 if (regexec(&cl->regex, buf + offset, cl->match + 1, pmatch, 0) != 0)
967 continue; /* regex doesn't match the status bar */
968
969 int first = pmatch[cl->match].rm_so + offset;
970 int last = pmatch[cl->match].rm_eo + offset;
971
972 if (first == last)
973 continue; /* ignore an empty regex */
974
975 if (!found)
976 {
977 chunks++;
978 mutt_mem_realloc(&syntax, chunks * sizeof(struct StatusSyntax));
979 }
980
981 i = chunks - 1;
982 if (!found || (first < syntax[i].first) ||
983 ((first == syntax[i].first) && (last > syntax[i].last)))
984 {
985 const struct AttrColor *ac_merge = merged_color_overlay(ac_base, &cl->attr_color);
986
987 syntax[i].attr_color = ac_merge;
988 syntax[i].first = first;
989 syntax[i].last = last;
990 }
991 found = true;
992 }
993
994 if (syntax)
995 {
996 offset = syntax[i].last;
997 }
998 } while (found);
999
1000 /* Only 'len' bytes will fit into 'max_cols' screen columns */
1001 len = mutt_wstr_trunc(buf, buflen, max_cols, NULL);
1002
1003 offset = 0;
1004
1005 if ((chunks > 0) && (syntax[0].first > 0))
1006 {
1007 /* Text before the first highlight */
1008 mutt_window_addnstr(win, buf, MIN(len, syntax[0].first));
1009 mutt_curses_set_color(ac_base);
1010 if (len <= syntax[0].first)
1011 goto dsl_finish; /* no more room */
1012
1013 offset = syntax[0].first;
1014 }
1015
1016 for (i = 0; i < chunks; i++)
1017 {
1018 /* Highlighted text */
1019 mutt_curses_set_color(syntax[i].attr_color);
1020 mutt_window_addnstr(win, buf + offset, MIN(len, syntax[i].last) - offset);
1021 if (len <= syntax[i].last)
1022 goto dsl_finish; /* no more room */
1023
1024 size_t next;
1025 if ((i + 1) == chunks)
1026 {
1027 next = len;
1028 }
1029 else
1030 {
1031 next = MIN(len, syntax[i + 1].first);
1032 }
1033
1034 mutt_curses_set_color(ac_base);
1035 offset = syntax[i].last;
1036 mutt_window_addnstr(win, buf + offset, next - offset);
1037
1038 offset = next;
1039 if (offset >= len)
1040 goto dsl_finish; /* no more room */
1041 }
1042
1043 mutt_curses_set_color(ac_base);
1044 if (offset < len)
1045 {
1046 /* Text after the last highlight */
1047 mutt_window_addnstr(win, buf + offset, len - offset);
1048 }
1049
1050 int width = mutt_strwidth(buf);
1051 if (width < max_cols)
1052 {
1053 /* Pad the rest of the line with whitespace */
1054 mutt_paddstr(win, max_cols - width, "");
1055 }
1056dsl_finish:
1057 FREE(&syntax);
1058}
1059
1070struct Mailbox *dlg_index(struct MuttWindow *dlg, struct Mailbox *m_init)
1071{
1072 /* Make sure use_threads/sort/sort_aux are coherent */
1074
1075 struct IndexSharedData *shared = dlg->wdata;
1077
1078 struct MuttWindow *panel_index = window_find_child(dlg, WT_INDEX);
1079
1080 struct IndexPrivateData *priv = panel_index->wdata;
1081 priv->win_index = window_find_child(panel_index, WT_MENU);
1082
1083 int op = OP_NULL;
1084
1085 if (shared->mailbox && (shared->mailbox->type == MUTT_NNTP))
1086 dlg->help_data = IndexNewsHelp;
1087 else
1088 dlg->help_data = IndexHelp;
1089 dlg->help_menu = MENU_INDEX;
1090
1091 priv->menu = priv->win_index->wdata;
1093 priv->menu->color = index_color;
1094 priv->menu->max = shared->mailbox ? shared->mailbox->vcount : 0;
1096
1097 struct MuttWindow *old_focus = window_set_focus(priv->menu->win);
1098 mutt_window_reflow(NULL);
1099
1100 if (!shared->attach_msg)
1101 {
1102 /* force the mailbox check after we enter the folder */
1104 }
1105#ifdef USE_INOTIFY
1106 mutt_monitor_add(NULL);
1107#endif
1108
1109 const bool c_collapse_all = cs_subset_bool(shared->sub, "collapse_all");
1110 if (mutt_using_threads() && c_collapse_all)
1111 {
1112 collapse_all(shared->mailbox_view, priv->menu, 0);
1114 }
1115
1116 int rc = 0;
1117 do
1118 {
1119 /* Clear the tag prefix unless we just started it.
1120 * Don't clear the prefix on a timeout, but do clear on an abort */
1121 if (priv->tag_prefix && (op != OP_TAG_PREFIX) &&
1122 (op != OP_TAG_PREFIX_COND) && (op != OP_TIMEOUT))
1123 {
1124 priv->tag_prefix = false;
1125 }
1126
1127 /* check if we need to resort the index because just about
1128 * any 'op' below could do mutt_enter_command(), either here or
1129 * from any new priv->menu launched, and change $sort/$sort_aux */
1130 if (OptNeedResort && shared->mailbox && (shared->mailbox->msg_count != 0) &&
1131 (menu_get_index(priv->menu) >= 0))
1132 {
1133 resort_index(shared->mailbox_view, priv->menu);
1134 }
1135
1136 priv->menu->max = shared->mailbox ? shared->mailbox->vcount : 0;
1137 priv->oldcount = shared->mailbox ? shared->mailbox->msg_count : 0;
1138
1139 if (shared->mailbox && shared->mailbox_view)
1140 {
1142
1143 shared->mailbox_view->menu = priv->menu;
1144 /* check for new mail in the mailbox. If nonzero, then something has
1145 * changed about the file (either we got new mail or the file was
1146 * modified underneath us.) */
1147 enum MxStatus check = mx_mbox_check(shared->mailbox);
1148
1149 if (check == MX_STATUS_ERROR)
1150 {
1151 if (buf_is_empty(&shared->mailbox->pathbuf))
1152 {
1153 /* fatal error occurred */
1154 mview_free(&shared->mailbox_view);
1156 }
1157
1159 }
1160 else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
1161 (check == MX_STATUS_FLAGS))
1162 {
1163 /* notify the user of new mail */
1164 if (check == MX_STATUS_REOPENED)
1165 {
1166 mutt_error(_("Mailbox was externally modified. Flags may be wrong."));
1167 }
1168 else if (check == MX_STATUS_NEW_MAIL)
1169 {
1170 for (size_t i = 0; i < shared->mailbox->msg_count; i++)
1171 {
1172 const struct Email *e = shared->mailbox->emails[i];
1173 if (e && !e->read && !e->old)
1174 {
1175 mutt_message(_("New mail in this mailbox"));
1176 const bool c_beep_new = cs_subset_bool(shared->sub, "beep_new");
1177 if (c_beep_new)
1178 mutt_beep(true);
1179 const struct Expando *c_new_mail_command =
1180 cs_subset_expando(shared->sub, "new_mail_command");
1181 if (c_new_mail_command)
1182 {
1183 struct Buffer *cmd = buf_pool_get();
1184 menu_status_line(cmd, shared, NULL, -1, c_new_mail_command);
1185 if (mutt_system(buf_string(cmd)) != 0)
1186 mutt_error(_("Error running \"%s\""), buf_string(cmd));
1187 buf_pool_release(&cmd);
1188 }
1189 break;
1190 }
1191 }
1192 }
1193 else if (check == MX_STATUS_FLAGS)
1194 {
1195 mutt_message(_("Mailbox was externally modified"));
1196 }
1197
1198 /* avoid the message being overwritten by mailbox */
1199 priv->do_mailbox_notify = false;
1200
1201 bool verbose = shared->mailbox->verbose;
1202 shared->mailbox->verbose = false;
1203 update_index(priv->menu, shared->mailbox_view, check, priv->oldcount, shared);
1204 shared->mailbox->verbose = verbose;
1205 priv->menu->max = shared->mailbox->vcount;
1208 }
1209
1211 menu_get_index(priv->menu)));
1212 }
1213
1214 if (!shared->attach_msg)
1215 {
1216 /* check for new mail in the incoming folders */
1218 if (priv->do_mailbox_notify)
1219 {
1220 if (mutt_mailbox_notify(shared->mailbox))
1221 {
1222 const bool c_beep_new = cs_subset_bool(shared->sub, "beep_new");
1223 if (c_beep_new)
1224 mutt_beep(true);
1225 const struct Expando *c_new_mail_command = cs_subset_expando(shared->sub, "new_mail_command");
1226 if (c_new_mail_command)
1227 {
1228 struct Buffer *cmd = buf_pool_get();
1229 menu_status_line(cmd, shared, priv->menu, -1, c_new_mail_command);
1230 if (mutt_system(buf_string(cmd)) != 0)
1231 mutt_error(_("Error running \"%s\""), buf_string(cmd));
1232 buf_pool_release(&cmd);
1233 }
1234 }
1235 }
1236 else
1237 {
1238 priv->do_mailbox_notify = true;
1239 }
1240 }
1241
1242 window_redraw(NULL);
1243
1244 /* give visual indication that the next command is a tag- command */
1245 if (priv->tag_prefix)
1246 {
1247 msgwin_set_text(NULL, "tag-", MT_COLOR_NORMAL);
1248 }
1249
1250 const bool c_arrow_cursor = cs_subset_bool(shared->sub, "arrow_cursor");
1251 const bool c_braille_friendly = cs_subset_bool(shared->sub, "braille_friendly");
1252 const int index = menu_get_index(priv->menu);
1253 if (c_arrow_cursor)
1254 {
1255 const char *const c_arrow_string = cs_subset_string(shared->sub, "arrow_string");
1256 const int arrow_width = mutt_strwidth(c_arrow_string);
1257 mutt_window_move(priv->menu->win, arrow_width, index - priv->menu->top);
1258 }
1259 else if (c_braille_friendly)
1260 {
1261 mutt_window_move(priv->menu->win, 0, index - priv->menu->top);
1262 }
1263 else
1264 {
1265 mutt_window_move(priv->menu->win, priv->menu->win->state.cols - 1,
1266 index - priv->menu->top);
1267 }
1268 mutt_refresh();
1269
1270 window_redraw(NULL);
1272
1273 if (op == OP_REPAINT)
1274 {
1275 /* force a real complete redraw. clrtobot() doesn't seem to be able
1276 * to handle every case without this. */
1277 msgwin_clear_text(NULL);
1278 mutt_refresh();
1279 continue;
1280 }
1281
1282 /* either user abort or timeout */
1283 if (op < OP_NULL)
1284 {
1285 if (priv->tag_prefix)
1286 msgwin_clear_text(NULL);
1287 continue;
1288 }
1289
1290 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
1291
1292 /* special handling for the priv->tag-prefix function */
1293 const bool c_auto_tag = cs_subset_bool(shared->sub, "auto_tag");
1294 if ((op == OP_TAG_PREFIX) || (op == OP_TAG_PREFIX_COND))
1295 {
1296 /* A second priv->tag-prefix command aborts */
1297 if (priv->tag_prefix)
1298 {
1299 priv->tag_prefix = false;
1300 msgwin_clear_text(NULL);
1301 continue;
1302 }
1303
1304 if (!shared->mailbox)
1305 {
1306 mutt_error(_("No mailbox is open"));
1307 continue;
1308 }
1309
1310 if (shared->mailbox->msg_tagged == 0)
1311 {
1312 if (op == OP_TAG_PREFIX)
1313 {
1314 mutt_error(_("No tagged messages"));
1315 }
1316 else if (op == OP_TAG_PREFIX_COND)
1317 {
1319 mutt_message(_("Nothing to do"));
1320 }
1321 continue;
1322 }
1323
1324 /* get the real command */
1325 priv->tag_prefix = true;
1326 continue;
1327 }
1328 else if (c_auto_tag && shared->mailbox && (shared->mailbox->msg_tagged != 0))
1329 {
1330 priv->tag_prefix = true;
1331 }
1332
1334
1335 OptNews = false; /* for any case */
1336
1337#ifdef USE_NOTMUCH
1338 nm_db_debug_check(shared->mailbox);
1339#endif
1340
1341 rc = index_function_dispatcher(priv->win_index, op);
1342
1343 if (rc == FR_UNKNOWN)
1344 rc = menu_function_dispatcher(priv->win_index, op);
1345
1346 if (rc == FR_UNKNOWN)
1347 {
1348 struct MuttWindow *win_sidebar = window_find_child(dlg, WT_SIDEBAR);
1349 rc = sb_function_dispatcher(win_sidebar, op);
1350 }
1351 if (rc == FR_UNKNOWN)
1352 rc = global_function_dispatcher(NULL, op);
1353
1354 if (rc == FR_UNKNOWN)
1356
1357#ifdef USE_NOTMUCH
1358 nm_db_debug_check(shared->mailbox);
1359#endif
1360 } while (rc != FR_DONE);
1361
1362 mview_free(&shared->mailbox_view);
1363 window_set_focus(old_focus);
1364
1365 return shared->mailbox;
1366}
1367
1373void mutt_set_header_color(struct Mailbox *m, struct Email *e)
1374{
1375 if (!e)
1376 return;
1377
1378 struct RegexColor *color = NULL;
1379 struct PatternCache cache = { 0 };
1380
1381 const struct AttrColor *ac_merge = NULL;
1383 {
1385 MUTT_MATCH_FULL_ADDRESS, m, e, &cache))
1386 {
1387 ac_merge = merged_color_overlay(ac_merge, &color->attr_color);
1388 }
1389 }
1390
1391 struct AttrColor *ac_normal = simple_color_get(MT_COLOR_NORMAL);
1392 if (ac_merge)
1393 ac_merge = merged_color_overlay(ac_normal, ac_merge);
1394 else
1395 ac_merge = ac_normal;
1396
1397 e->attr_color = ac_merge;
1398}
1399
1405{
1409
1410 struct IndexSharedData *shared = index_shared_data_new();
1411 notify_set_parent(shared->notify, dlg->notify);
1412
1413 dlg->wdata = shared;
1415
1416 const bool c_status_on_top = cs_subset_bool(NeoMutt->sub, "status_on_top");
1417
1418 struct MuttWindow *panel_index = ipanel_new(c_status_on_top, shared);
1419 struct MuttWindow *panel_pager = ppanel_new(c_status_on_top, shared);
1420
1421 mutt_window_add_child(dlg, panel_index);
1422 mutt_window_add_child(dlg, panel_pager);
1423
1424 return dlg;
1425}
1426
1432void index_change_folder(struct MuttWindow *dlg, struct Mailbox *m)
1433{
1434 if (!dlg || !m)
1435 return;
1436
1437 struct IndexSharedData *shared = dlg->wdata;
1438 if (!shared)
1439 return;
1440
1441 struct MuttWindow *panel_index = window_find_child(dlg, WT_INDEX);
1442 if (!panel_index)
1443 return;
1444
1445 struct IndexPrivateData *priv = panel_index->wdata;
1446 if (!priv)
1447 return;
1448
1449 change_folder_mailbox(priv->menu, m, &priv->oldcount, shared, false);
1450}
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
Color and attribute parsing.
struct RegexColorList * regex_colors_get_list(enum ColorId cid)
Return the RegexColorList for a colour id.
Definition: regex.c:184
struct AttrColor * simple_color_get(enum ColorId cid)
Get the colour of an object by its ID.
Definition: simple.c:88
@ MT_COLOR_STATUS
Status bar (takes a pattern)
Definition: color.h:75
@ MT_COLOR_NORMAL
Plain text.
Definition: color.h:59
@ MT_COLOR_INDEX
Index: default colour.
Definition: color.h:83
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
Definition: compile.c:778
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
Definition: helpers.c:266
const struct Expando * cs_subset_expando(const struct ConfigSubset *sub, const char *name)
Get an Expando config item by name.
Definition: config_type.c:357
Convenience wrapper for the config headers.
Connection Library.
Convenience wrapper for the core headers.
void mailbox_gc_run(void)
Run the garbage-collection.
Definition: mailbox.c:312
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:89
struct Mailbox * mailbox_find_name(const char *name)
Find the mailbox with a given name.
Definition: mailbox.c:187
@ NT_MAILBOX_DELETE
Mailbox is about to be deleted.
Definition: mailbox.h:183
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
uint16_t AclFlags
ACL Rights - These show permission to...
Definition: mailbox.h:59
MailboxType
Supported mailbox formats.
Definition: mailbox.h:41
@ MUTT_MAILBOX_ERROR
Error occurred examining Mailbox.
Definition: mailbox.h:43
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
size_t mutt_wstr_trunc(const char *src, size_t maxlen, size_t maxwid, size_t *width)
Work out how to truncate a widechar string.
Definition: curs_lib.c:383
void mutt_paddstr(struct MuttWindow *win, int n, const char *s)
Display a string on screen, padded if necessary.
Definition: curs_lib.c:341
void mutt_refresh(void)
Force a refresh of the screen.
Definition: curs_lib.c:78
void mutt_beep(bool force)
Irritate the user.
Definition: curs_lib.c:68
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
bool check_acl(struct Mailbox *m, AclFlags acl, const char *msg)
Check the ACLs for a function.
Definition: dlg_index.c:139
const struct Mapping IndexNewsHelp[]
Help Bar for the News Index dialog.
Definition: dlg_index.c:118
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.
Definition: dlg_index.c:612
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.
Definition: dlg_index.c:733
void mutt_draw_statusline(struct MuttWindow *win, int max_cols, const char *buf, size_t buflen)
Draw a highlighted status bar.
Definition: dlg_index.c:929
void update_index(struct Menu *menu, struct MailboxView *mv, enum MxStatus check, int oldcount, const struct IndexSharedData *shared)
Update the index.
Definition: dlg_index.c:543
void mutt_set_header_color(struct Mailbox *m, struct Email *e)
Select a colour for a message.
Definition: dlg_index.c:1373
void index_change_folder(struct MuttWindow *dlg, struct Mailbox *m)
Change the current folder, cautiously.
Definition: dlg_index.c:1432
int find_first_message(struct MailboxView *mv)
Get index of first new message.
Definition: dlg_index.c:310
static const struct Mapping IndexHelp[]
Help Bar for the Index dialog.
Definition: dlg_index.c:103
static void update_index_threaded(struct MailboxView *mv, enum MxStatus check, int oldcount)
Update the index (if threaded)
Definition: dlg_index.c:412
void resort_index(struct MailboxView *mv, struct Menu *menu)
Resort the index.
Definition: dlg_index.c:370
int find_next_undeleted(struct MailboxView *mv, int msgno, bool uncollapse)
Find the next undeleted email.
Definition: dlg_index.c:242
static void update_index_unthreaded(struct MailboxView *mv, enum MxStatus check)
Update the index (if unthreaded)
Definition: dlg_index.c:494
void collapse_all(struct MailboxView *mv, struct Menu *menu, int toggle)
Collapse/uncollapse all threads.
Definition: dlg_index.c:166
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.
Definition: dlg_index.c:758
int find_previous_undeleted(struct MailboxView *mv, int msgno, bool uncollapse)
Find the previous undeleted email.
Definition: dlg_index.c:276
struct MuttWindow * index_pager_init(void)
Allocate the Windows for the Index/Pager.
Definition: dlg_index.c:1404
static void uncollapse_thread(struct MailboxView *mv, int index)
Open a collapsed thread.
Definition: dlg_index.c:220
Structs that make up an email.
bool mutt_pattern_exec(struct Pattern *pat, PatternExecFlags flags, struct Mailbox *m, struct Email *e, struct PatternCache *cache)
Match a pattern against an email header.
Definition: exec.c:1132
Parse Expando string.
int km_dokey(enum MenuType mtype, GetChFlags flags)
Determine what a keypress should do.
Definition: get.c:464
void mutt_flush_macro_to_endcond(void)
Drop a macro from the input buffer.
Definition: get.c:166
void km_error_key(enum MenuType mtype)
Handle an unbound key sequence.
Definition: get.c:294
bool OptNews
(pseudo) used to change reader mode
Definition: globals.c:70
char * LastFolder
Previously selected mailbox.
Definition: globals.c:44
char * CurrentFolder
Currently selected mailbox.
Definition: globals.c:43
bool OptNeedResort
(pseudo) used to force a re-sort
Definition: globals.c:69
int sb_function_dispatcher(struct MuttWindow *win, int op)
Perform a Sidebar function - Implements function_dispatcher_t -.
Definition: functions.c:375
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 index_function_dispatcher(struct MuttWindow *win, int op)
Perform an Index function - Implements function_dispatcher_t -.
Definition: functions.c:3262
struct Mailbox * dlg_index(struct MuttWindow *dlg, struct Mailbox *m_init)
Display a list of emails -.
Definition: dlg_index.c:1070
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_message(...)
Definition: logging2.h:91
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
const struct AttrColor * index_color(struct Menu *menu, int line)
Calculate the colour for a line of the index - Implements Menu::color() -.
Definition: dlg_index.c:897
int index_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format an Email for the Menu - Implements Menu::make_entry() -.
Definition: dlg_index.c:797
static int index_mailbox_observer(struct NotifyCallback *nc)
Notification that a Mailbox has changed - Implements observer_t -.
Definition: dlg_index.c:586
void index_shared_data_free(struct MuttWindow *win, void **ptr)
Free Shared Index Data - Implements MuttWindow::wdata_free() -.
Definition: shared_data.c:278
Convenience wrapper for the gui headers.
int mutt_make_string(struct Buffer *buf, size_t max_cols, const struct Expando *exp, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1796
String processing routines to generate the mail index.
void mutt_folder_hook(const char *path, const char *desc)
Perform a folder hook.
Definition: hook.c:623
Parse and execute user-defined hooks.
void index_shared_data_set_email(struct IndexSharedData *shared, struct Email *e)
Set the current Email for the Index and friends.
Definition: shared_data.c:235
bool index_shared_data_is_cur_email(const struct IndexSharedData *shared, const struct Email *e)
Check whether an email is the currently selected Email.
Definition: shared_data.c:264
struct IndexSharedData * index_shared_data_new(void)
Create new Index Data.
Definition: shared_data.c:307
void index_shared_data_set_mview(struct IndexSharedData *shared, struct MailboxView *mv)
Set the MailboxView for the Index and friends.
Definition: shared_data.c:160
Data shared between Index, Pager and Sidebar.
void index_adjust_sort_threads(const struct ConfigSubset *sub)
Adjust use_threads/sort/sort_aux.
Definition: index.c:184
struct MuttWindow * ipanel_new(bool status_on_top, struct IndexSharedData *shared)
Create the Windows for the Index panel.
Definition: ipanel.c:121
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
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:91
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:115
#define FREE(x)
Definition: memory.h:45
#define MIN(a, b)
Definition: memory.h:32
#define MAX(a, b)
Definition: memory.h:31
GUI present the user with a selectable list.
#define MENU_REDRAW_FULL
Redraw everything.
Definition: lib.h:59
#define MENU_REDRAW_INDEX
Redraw the index.
Definition: lib.h:56
void menu_queue_redraw(struct Menu *menu, MenuRedrawFlags redraw)
Queue a request for a redraw.
Definition: menu.c:184
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:160
MenuRedrawFlags menu_set_index(struct Menu *menu, int index)
Set the current selection in the Menu.
Definition: menu.c:174
const struct AttrColor * merged_color_overlay(const struct AttrColor *base, const struct AttrColor *over)
Combine two colours.
Definition: merged.c:107
int mutt_monitor_add(struct Mailbox *m)
Add a watch for a mailbox.
Definition: monitor.c:484
int mutt_monitor_remove(struct Mailbox *m)
Remove a watch for a mailbox.
Definition: monitor.c:528
Monitor files for changes.
void msgwin_clear_text(struct MuttWindow *win)
Clear the text in the Message Window.
Definition: msgwin.c:519
void msgwin_set_text(struct MuttWindow *win, const char *text, enum ColorId color)
Set the text for the Message Window.
Definition: msgwin.c:484
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
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:95
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:280
void mutt_curses_set_color(const struct AttrColor *ac)
Set the colour and attributes for text.
Definition: mutt_curses.c:38
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
NeoMutt Logging.
int mutt_mailbox_check(struct Mailbox *m_cur, CheckStatsFlags flags)
Check all all Mailboxes for new mail.
Definition: mutt_mailbox.c:169
bool mutt_mailbox_notify(struct Mailbox *m_cur)
Notify the user if there's new mail.
Definition: mutt_mailbox.c:235
Mailbox helper functions.
void mutt_thread_collapse(struct ThreadsContext *tctx, bool collapse)
Toggle collapse.
Definition: mutt_thread.c:1789
enum UseThreads mutt_thread_style(void)
Which threading style is active?
Definition: mutt_thread.c:82
off_t mutt_set_vnum(struct Mailbox *m)
Set the virtual index number of all the messages in a mailbox.
Definition: mutt_thread.c:1404
bool mutt_thread_can_collapse(struct Email *e)
Check whether a thread can be collapsed.
Definition: mutt_thread.c:1817
int mutt_parent_message(struct Email *e, bool find_root)
Find the parent of a message.
Definition: mutt_thread.c:1354
Create/manipulate threading in emails.
UseThreads
Which threading style is active, $use_threads.
Definition: mutt_thread.h:97
@ UT_FLAT
Unthreaded.
Definition: mutt_thread.h:99
@ UT_THREADS
Normal threading (root above subthreads)
Definition: mutt_thread.h:100
@ UT_REVERSE
Reverse threading (subthreads above root)
Definition: mutt_thread.h:101
#define mutt_using_threads()
Definition: mutt_thread.h:114
#define mutt_uncollapse_thread(e)
Definition: mutt_thread.h:108
#define mutt_collapse_thread(e)
Definition: mutt_thread.h:107
void window_redraw(struct MuttWindow *win)
Reflow, recalc and repaint a tree of Windows.
Definition: mutt_window.c:634
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:344
void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
Add a child to Window.
Definition: mutt_window.c:446
struct MuttWindow * mutt_window_new(enum WindowType type, enum MuttWindowOrientation orient, enum MuttWindowSize size, int cols, int rows)
Create a new Window.
Definition: mutt_window.c:182
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:297
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
int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
Write a partial string to a Window.
Definition: mutt_window.c:401
@ WT_DLG_INDEX
Index Dialog, dlg_index()
Definition: mutt_window.h:86
@ WT_INDEX
A panel containing the Index Window.
Definition: mutt_window.h:97
@ WT_SIDEBAR
Side panel containing Accounts or groups of data.
Definition: mutt_window.h:101
@ WT_MENU
An Window containing a Menu.
Definition: mutt_window.h:98
@ MUTT_WIN_ORIENT_HORIZONTAL
Window uses all available horizontal space.
Definition: mutt_window.h:39
#define MUTT_WIN_SIZE_UNLIMITED
Use as much space as possible.
Definition: mutt_window.h:52
@ MUTT_WIN_SIZE_MAXIMISE
Window wants as much space as possible.
Definition: mutt_window.h:48
struct Email * mutt_get_virt_email(struct Mailbox *m, int vnum)
Get a virtual Email.
Definition: mview.c:418
void mview_free(struct MailboxView **ptr)
Free a MailboxView.
Definition: mview.c:50
bool mview_has_limit(const struct MailboxView *mv)
Is a limit active?
Definition: mview.c:439
struct MailboxView * mview_new(struct Mailbox *m, struct Notify *parent)
Create a new MailboxView.
Definition: mview.c:91
View of a Mailbox.
int mx_msg_padding_size(struct Mailbox *m)
Bytes of padding between messages - Wrapper for MxOps::msg_padding_size()
Definition: mx.c:1505
int mx_path_canon(struct Buffer *path, const char *folder, enum MailboxType *type)
Canonicalise a mailbox path - Wrapper for MxOps::path_canon()
Definition: mx.c:1367
bool mx_mbox_open(struct Mailbox *m, OpenMailboxFlags flags)
Open a mailbox and parse it.
Definition: mx.c:288
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1321
struct Mailbox * mx_path_resolve(const char *path)
Get a Mailbox for a path.
Definition: mx.c:1636
enum MxStatus mx_mbox_check(struct Mailbox *m)
Check for new mail - Wrapper for MxOps::mbox_check()
Definition: mx.c:1105
enum MxStatus mx_mbox_close(struct Mailbox *m)
Save changes and close mailbox.
Definition: mx.c:598
API for mailboxes.
#define MUTT_READONLY
Open in read-only mode.
Definition: mxapi.h:43
uint8_t OpenMailboxFlags
Flags for mutt_open_mailbox(), e.g. MUTT_NOSORT.
Definition: mxapi.h:39
#define MUTT_MAILBOX_CHECK_NO_FLAGS
No flags are set.
Definition: mxapi.h:53
#define MUTT_OPEN_NO_FLAGS
No flags are set.
Definition: mxapi.h:40
#define MUTT_MAILBOX_CHECK_FORCE
Ignore MailboxTime and check for new mail.
Definition: mxapi.h:54
MxStatus
Return values from mbox_check(), mbox_check_stats(), mbox_sync(), and mbox_close()
Definition: mxapi.h:63
@ MX_STATUS_ERROR
An error occurred.
Definition: mxapi.h:64
@ MX_STATUS_OK
No changes.
Definition: mxapi.h:65
@ MX_STATUS_FLAGS
Nondestructive flags change (IMAP)
Definition: mxapi.h:69
@ MX_STATUS_REOPENED
Mailbox was reopened.
Definition: mxapi.h:68
@ MX_STATUS_NEW_MAIL
New mail received in Mailbox.
Definition: mxapi.h:66
Nntp-specific Account data.
Usenet network mailbox type; talk to an NNTP server.
void nntp_expand_path(char *buf, size_t buflen, struct ConnAccount *acct)
Make fully qualified url from newsgroup name.
Definition: newsrc.c:558
struct NntpAccountData * CurrentNewsSrv
Current NNTP news server.
Definition: nntp.c:77
@ NT_MAILBOX
Mailbox has changed, NotifyMailbox, EventMailbox.
Definition: notify_type.h:49
void nm_db_debug_check(struct Mailbox *m)
Check if the database is open.
Definition: db.c:397
Notmuch virtual mailbox type.
char * nm_url_from_query(struct Mailbox *m, char *buf, size_t buflen)
Turn a query into a URL.
Definition: notmuch.c:1579
const char * opcodes_get_name(int op)
Get the name of an opcode.
Definition: opcodes.c:48
#define OP_TIMEOUT
1 second with no events
Definition: opcodes.h:36
#define OP_REPAINT
Repaint is needed.
Definition: opcodes.h:34
GUI display a file/email/help in a viewport with paging.
struct MuttWindow * ppanel_new(bool status_on_top, struct IndexSharedData *shared)
Create the Windows for the Pager panel.
Definition: ppanel.c:121
Private state data for the Pager.
Match patterns to emails.
#define MUTT_MATCH_FULL_ADDRESS
Match the full address.
Definition: lib.h:106
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
Prototypes for many functions.
int mutt_system(const char *cmd)
Run an external command.
Definition: system.c:52
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define SLIST_FIRST(head)
Definition: queue.h:229
#define MUTT_FORMAT_FORCESUBJ
Print the subject even if unchanged.
Definition: render.h:34
#define MUTT_FORMAT_INDEX
This is a main index entry.
Definition: render.h:38
#define MUTT_FORMAT_TREE
Draw the thread tree.
Definition: render.h:35
#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
Sidebar functions.
GUI display the mailboxes in a side panel.
GUI display the mailboxes in a side panel.
#define ASSERT(COND)
Definition: signal2.h:58
#define SORT_MASK
Mask for the sort id.
Definition: sort2.h:70
SortType
Methods for sorting.
Definition: sort2.h:34
@ SORT_THREADS
Sort by email threads.
Definition: sort2.h:41
#define SORT_REVERSE
Reverse the order of the sort.
Definition: sort2.h:71
void mutt_sort_headers(struct MailboxView *mv, bool init)
Sort emails by their headers.
Definition: sort.c:350
Assorted sorting methods.
void menu_status_line(struct Buffer *buf, struct IndexSharedData *shared, struct Menu *menu, int max_cols, const struct Expando *exp)
Create the status line.
Definition: status.c:496
GUI display a user-configurable status line.
Key value store.
A curses colour and its attributes.
Definition: attr.h:66
The body of an email.
Definition: body.h:36
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
long hdr_offset
Offset in stream where the headers begin.
Definition: body.h:80
String manipulation buffer.
Definition: buffer.h:36
size_t dsize
Length of data.
Definition: buffer.h:39
char * data
Pointer to data.
Definition: buffer.h:37
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:49
The envelope/body of an email.
Definition: email.h:39
bool read
Email is read.
Definition: email.h:50
bool display_subject
Used for threading.
Definition: email.h:104
bool visible
Is this message part of the view?
Definition: email.h:124
bool limit_visited
Has the limit pattern been applied to this message?
Definition: email.h:125
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:123
struct Body * body
List of MIME parts.
Definition: email.h:69
char * tree
Character string to print thread tree.
Definition: email.h:128
bool old
Email is seen, but unread.
Definition: email.h:49
LOFF_T offset
Where in the stream does this message begin?
Definition: email.h:71
const struct AttrColor * attr_color
Color-pair to use when displaying in the index.
Definition: email.h:115
int vnum
Virtual message number.
Definition: email.h:117
int msgno
Number displayed to the user.
Definition: email.h:114
bool deleted
Email is deleted.
Definition: email.h:78
int index
The absolute (unsorted) message number.
Definition: email.h:113
struct MuttThread * thread
Thread of Emails.
Definition: email.h:122
An Event that happened to a Mailbox.
Definition: mailbox.h:199
struct Mailbox * mailbox
The Mailbox this Event relates to.
Definition: mailbox.h:200
Parsed Expando trees.
Definition: expando.h:41
Private state data for the Index.
Definition: private_data.h:35
struct MuttWindow * win_index
Window for the Index.
Definition: private_data.h:42
struct IndexSharedData * shared
Shared Index data.
Definition: private_data.h:40
bool tag_prefix
tag-prefix has been pressed
Definition: private_data.h:36
bool do_mailbox_notify
Do we need to notify the user of new mail?
Definition: private_data.h:38
struct Menu * menu
Menu controlling the index.
Definition: private_data.h:41
int oldcount
Old count of mails in the mailbox.
Definition: private_data.h:37
Data shared between Index, Pager and Sidebar.
Definition: shared_data.h:37
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:41
bool attach_msg
Are we in "attach message" mode?
Definition: shared_data.h:46
struct ConfigSubset * sub
Config set to use.
Definition: shared_data.h:38
struct MailboxView * mailbox_view
Current Mailbox view.
Definition: shared_data.h:40
struct SearchState * search_state
State of the current search.
Definition: shared_data.h:45
struct Notify * notify
Notifications: NotifyIndex, IndexSharedData.
Definition: shared_data.h:44
View of a Mailbox.
Definition: mview.h:40
bool collapsed
Are all threads collapsed?
Definition: mview.h:49
struct Menu * menu
Needed for pattern compilation.
Definition: mview.h:47
off_t vsize
Size (in bytes) of the messages shown.
Definition: mview.h:41
struct PatternList * limit_pattern
Compiled limit pattern.
Definition: mview.h:43
struct ThreadsContext * threads
Threads context.
Definition: mview.h:44
int msg_in_pager
Message currently shown in the pager.
Definition: mview.h:45
struct Mailbox * mailbox
Current Mailbox.
Definition: mview.h:51
A mailbox.
Definition: mailbox.h:79
int vcount
The number of virtual messages.
Definition: mailbox.h:99
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:81
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:98
int msg_count
Total number of messages.
Definition: mailbox.h:88
AclFlags rights
ACL bits, see AclFlags.
Definition: mailbox.h:119
int email_max
Size of emails array.
Definition: mailbox.h:97
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
char * name
A short name for the Mailbox.
Definition: mailbox.h:82
struct Notify * notify
Notifications: NotifyMailbox, EventMailbox.
Definition: mailbox.h:145
struct Buffer pathbuf
Path of the Mailbox.
Definition: mailbox.h:80
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:121
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:94
bool verbose
Display status messages?
Definition: mailbox.h:117
struct ConfigSubset * sub
Inherited config items.
Definition: mailbox.h:83
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
int current
Current entry.
Definition: lib.h:80
const struct AttrColor *(* color)(struct Menu *menu, int line)
Definition: lib.h:143
int top
Entry that is the top of the current page.
Definition: lib.h:90
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
int page_len
Number of entries per screen.
Definition: lib.h:84
An Email conversation.
Definition: thread.h:34
struct MuttThread * parent
Parent of this Thread.
Definition: thread.h:44
struct MuttThread * prev
Previous sibling Thread.
Definition: thread.h:47
struct Email * message
Email this Thread refers to.
Definition: thread.h:49
const struct Mapping * help_data
Data for the Help Bar.
Definition: mutt_window.h:142
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
void(* wdata_free)(struct MuttWindow *win, void **ptr)
Definition: mutt_window.h:159
int help_menu
Menu for key bindings, e.g. MENU_PAGER.
Definition: mutt_window.h:141
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct Notify * notify
Notifications handler.
Definition: neomutt.h:43
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
struct Connection * conn
Connection to NNTP Server.
Definition: adata.h:62
Data passed to a notification function.
Definition: observer.h:34
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
Cache commonly-used patterns.
Definition: lib.h:117
A regular expression and a color to highlight a line.
Definition: regex4.h:36
regex_t regex
Compiled regex.
Definition: regex4.h:39
struct PatternList * color_pattern
Compiled pattern to speed up index color calculation.
Definition: regex4.h:41
struct AttrColor attr_color
Colour and attributes to apply.
Definition: regex4.h:37
int match
Substring to match, 0 for old behaviour.
Definition: regex4.h:40
struct PatternList * pattern
compiled search pattern
Definition: search_state.h:37
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
@ MENU_INDEX
Index panel (list of emails)
Definition: type.h:51