NeoMutt  2023-05-17-16-g61469c
Teaching an old dog new tricks
DOXYGEN
window.c
Go to the documentation of this file.
1
68#include "config.h"
69#include <stdbool.h>
70#include <stdint.h>
71#include <stdio.h>
72#include <string.h>
73#include "private.h"
74#include "mutt/lib.h"
75#include "config/lib.h"
76#include "email/lib.h"
77#include "core/lib.h"
78#include "gui/lib.h"
79#include "color/lib.h"
80#include "index/lib.h"
81#include "format_flags.h"
82#include "muttlib.h"
83
88{
89 struct SbEntry *entry;
91};
92
99static int imap_is_prefix(const char *folder, const char *mbox)
100{
101 int plen = 0;
102
103 struct Url *url_m = url_parse(mbox);
104 struct Url *url_f = url_parse(folder);
105 if (!url_m || !url_f)
106 goto done;
107
108 if (!mutt_istr_equal(url_m->host, url_f->host))
109 goto done;
110
111 if (url_m->user && url_f->user && !mutt_istr_equal(url_m->user, url_f->user))
112 goto done;
113
114 size_t mlen = mutt_str_len(url_m->path);
115 size_t flen = mutt_str_len(url_f->path);
116 if (flen > mlen)
117 goto done;
118
119 if (!mutt_strn_equal(url_m->path, url_f->path, flen))
120 goto done;
121
122 plen = strlen(mbox) - mlen + flen;
123
124done:
125 url_free(&url_m);
126 url_free(&url_f);
127
128 return plen;
129}
130
138static const char *abbrev_folder(const char *mbox, const char *folder, enum MailboxType type)
139{
140 if (!mbox || !folder)
141 return NULL;
142
143 if (type == MUTT_IMAP)
144 {
145 int prefix = imap_is_prefix(folder, mbox);
146 if (prefix == 0)
147 return NULL;
148 return mbox + prefix;
149 }
150
151 const char *const c_sidebar_delim_chars = cs_subset_string(NeoMutt->sub, "sidebar_delim_chars");
152 if (!c_sidebar_delim_chars)
153 return NULL;
154
155 size_t flen = mutt_str_len(folder);
156 if (flen == 0)
157 return NULL;
158 if (strchr(c_sidebar_delim_chars, folder[flen - 1])) // folder ends with a delimiter
159 flen--;
160
161 size_t mlen = mutt_str_len(mbox);
162 if (mlen < flen)
163 return NULL;
164
165 if (!mutt_strn_equal(folder, mbox, flen))
166 return NULL;
167
168 // After the match, check that mbox has a delimiter
169 if (!strchr(c_sidebar_delim_chars, mbox[flen]))
170 return NULL;
171
172 if (mlen > flen)
173 {
174 return mbox + flen + 1;
175 }
176
177 // mbox and folder are equal, use the chunk after the last delimiter
178 while (mlen--)
179 {
180 if (strchr(c_sidebar_delim_chars, mbox[mlen]))
181 {
182 return mbox + mlen + 1;
183 }
184 }
185
186 return NULL;
187}
188
202static const char *abbrev_url(const char *mbox, enum MailboxType type)
203{
204 /* This is large enough to skip `notmuch://`,
205 * but not so large that it will go past the host part. */
206 const int scheme_len = 10;
207
208 size_t len = mutt_str_len(mbox);
209 if ((len < scheme_len) || ((type != MUTT_NNTP) && (type != MUTT_IMAP) &&
210 (type != MUTT_NOTMUCH) && (type != MUTT_POP)))
211 {
212 return mbox;
213 }
214
215 const char split = (type == MUTT_NOTMUCH) ? '?' : '/';
216
217 // Skip over the scheme, e.g. `imaps://`, `notmuch://`
218 const char *last = strchr(mbox + scheme_len, split);
219 if (last)
220 mbox = last + 1;
221 return mbox;
222}
223
231static size_t add_indent(char *buf, size_t buflen, const struct SbEntry *sbe)
232{
233 size_t res = 0;
234 const char *const c_sidebar_indent_string = cs_subset_string(NeoMutt->sub, "sidebar_indent_string");
235 for (int i = 0; i < sbe->depth; i++)
236 {
237 res += mutt_str_copy(buf + res, c_sidebar_indent_string, buflen - res);
238 }
239 return res;
240}
241
249static struct AttrColor *calc_color(const struct Mailbox *m, bool current, bool highlight)
250{
251 struct AttrColor *ac = NULL;
252
253 const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
255 mutt_str_equal(mailbox_path(m), c_spool_file))
256 {
258 }
259
261 {
263 }
264
266 {
268 }
269
271 {
273 }
274
276 {
278 }
279
282 ac = merged_color_overlay(ac_bg, ac);
283
284 if (current || highlight)
285 {
286 int color;
287 if (current)
288 {
291 else
292 color = MT_COLOR_INDICATOR;
293 }
294 else
295 {
297 }
298
299 ac = merged_color_overlay(ac, simple_color_get(color));
300 }
301
302 return ac;
303}
304
312static int calc_path_depth(const char *mbox, const char *delims, const char **last_part)
313{
314 if (!mbox || !delims || !last_part)
315 return 0;
316
317 int depth = 0;
318 const char *match = NULL;
319 while ((match = strpbrk(mbox, delims)))
320 {
321 depth++;
322 mbox = match + 1;
323 }
324
325 *last_part = mbox;
326 return depth;
327}
328
348static const char *sidebar_format_str(char *buf, size_t buflen, size_t col, int cols,
349 char op, const char *src, const char *prec,
350 const char *if_str, const char *else_str,
351 intptr_t data, MuttFormatFlags flags)
352{
353 struct SidebarFormatData *sfdata = (struct SidebarFormatData *) data;
354 struct SbEntry *sbe = sfdata->entry;
355 struct IndexSharedData *shared = sfdata->shared;
356 char fmt[256] = { 0 };
357
358 if (!sbe || !shared || !buf)
359 return src;
360
361 buf[0] = '\0'; /* Just in case there's nothing to do */
362
363 struct Mailbox *m = sbe->mailbox;
364 if (!m)
365 return src;
366
367 struct Mailbox *m_cur = shared->mailbox;
368
369 bool c = m_cur && mutt_str_equal(m_cur->realpath, m->realpath);
370
371 bool optional = (flags & MUTT_FORMAT_OPTIONAL);
372
373 switch (op)
374 {
375 case 'B':
376 case 'D':
377 {
378 char indented[256] = { 0 };
379 size_t ilen = sizeof(indented);
380 size_t off = add_indent(indented, ilen, sbe);
381 snprintf(indented + off, ilen - off, "%s",
382 ((op == 'D') && sbe->mailbox->name) ? sbe->mailbox->name : sbe->box);
383 mutt_format_s(buf, buflen, prec, indented);
384 break;
385 }
386
387 case 'd':
388 if (!optional)
389 {
390 snprintf(fmt, sizeof(fmt), "%%%sd", prec);
391 snprintf(buf, buflen, fmt, c ? m_cur->msg_deleted : 0);
392 }
393 else if ((c && (m_cur->msg_deleted == 0)) || !c)
394 {
395 optional = false;
396 }
397 break;
398
399 case 'F':
400 if (!optional)
401 {
402 snprintf(fmt, sizeof(fmt), "%%%sd", prec);
403 snprintf(buf, buflen, fmt, m->msg_flagged);
404 }
405 else if (m->msg_flagged == 0)
406 {
407 optional = false;
408 }
409 break;
410
411 case 'L':
412 if (!optional)
413 {
414 snprintf(fmt, sizeof(fmt), "%%%sd", prec);
415 snprintf(buf, buflen, fmt, c ? m_cur->vcount : m->msg_count);
416 }
417 else if ((c && (m_cur->vcount == m->msg_count)) || !c)
418 {
419 optional = false;
420 }
421 break;
422
423 case 'N':
424 if (!optional)
425 {
426 snprintf(fmt, sizeof(fmt), "%%%sd", prec);
427 snprintf(buf, buflen, fmt, m->msg_unread);
428 }
429 else if (m->msg_unread == 0)
430 {
431 optional = false;
432 }
433 break;
434
435 case 'n':
436 if (!optional)
437 {
438 snprintf(fmt, sizeof(fmt), "%%%sc", prec);
439 snprintf(buf, buflen, fmt, m->has_new ? 'N' : ' ');
440 }
441 else if (m->has_new == false)
442 {
443 optional = false;
444 }
445 break;
446
447 case 'o':
448 if (!optional)
449 {
450 snprintf(fmt, sizeof(fmt), "%%%sd", prec);
451 snprintf(buf, buflen, fmt, m->msg_unread - m->msg_new);
452 }
453 else if ((c && (m_cur->msg_unread - m_cur->msg_new) == 0) || !c)
454 {
455 optional = false;
456 }
457 break;
458
459 case 'r':
460 if (!optional)
461 {
462 snprintf(fmt, sizeof(fmt), "%%%sd", prec);
463 snprintf(buf, buflen, fmt, m->msg_count - m->msg_unread);
464 }
465 else if ((c && (m_cur->msg_count - m_cur->msg_unread) == 0) || !c)
466 {
467 optional = false;
468 }
469 break;
470
471 case 'S':
472 if (!optional)
473 {
474 snprintf(fmt, sizeof(fmt), "%%%sd", prec);
475 snprintf(buf, buflen, fmt, m->msg_count);
476 }
477 else if (m->msg_count == 0)
478 {
479 optional = false;
480 }
481 break;
482
483 case 't':
484 if (!optional)
485 {
486 snprintf(fmt, sizeof(fmt), "%%%sd", prec);
487 snprintf(buf, buflen, fmt, c ? m_cur->msg_tagged : 0);
488 }
489 else if ((c && (m_cur->msg_tagged == 0)) || !c)
490 {
491 optional = false;
492 }
493 break;
494
495 case 'Z':
496 if (!optional)
497 {
498 snprintf(fmt, sizeof(fmt), "%%%sd", prec);
499 snprintf(buf, buflen, fmt, m->msg_new);
500 }
501 else if ((c && (m_cur->msg_new) == 0) || !c)
502 {
503 optional = false;
504 }
505 break;
506
507 case '!':
508 if (m->msg_flagged == 0)
509 {
510 mutt_format_s(buf, buflen, prec, "");
511 }
512 else if (m->msg_flagged == 1)
513 {
514 mutt_format_s(buf, buflen, prec, "!");
515 }
516 else if (m->msg_flagged == 2)
517 {
518 mutt_format_s(buf, buflen, prec, "!!");
519 }
520 else
521 {
522 snprintf(fmt, sizeof(fmt), "%d!", m->msg_flagged);
523 mutt_format_s(buf, buflen, prec, fmt);
524 }
525 break;
526 }
527
528 if (optional)
529 {
530 mutt_expando_format(buf, buflen, col, cols, if_str, sidebar_format_str, data, flags);
531 }
532 else if (flags & MUTT_FORMAT_OPTIONAL)
533 {
534 mutt_expando_format(buf, buflen, col, cols, else_str, sidebar_format_str, data, flags);
535 }
536
537 /* We return the format string, unchanged */
538 return src;
539}
540
554static void make_sidebar_entry(char *buf, size_t buflen, int width,
555 struct SbEntry *sbe, struct IndexSharedData *shared)
556{
557 struct SidebarFormatData data = { sbe, shared };
558
559 const char *const c_sidebar_format = cs_subset_string(NeoMutt->sub, "sidebar_format");
560 mutt_expando_format(buf, buflen, 0, width, NONULL(c_sidebar_format),
561 sidebar_format_str, (intptr_t) &data, MUTT_FORMAT_NO_FLAGS);
562
563 /* Force string to be exactly the right width */
564 int w = mutt_strwidth(buf);
565 int s = mutt_str_len(buf);
566 width = MIN(buflen, width);
567 if (w < width)
568 {
569 /* Pad with spaces */
570 memset(buf + s, ' ', width - w);
571 buf[s + width - w] = '\0';
572 }
573 else if (w > width)
574 {
575 /* Truncate to fit */
576 size_t len = mutt_wstr_trunc(buf, buflen, width, NULL);
577 buf[len] = '\0';
578 }
579}
580
594{
595 /* Aliases for readability */
596 const bool c_sidebar_new_mail_only = cs_subset_bool(NeoMutt->sub, "sidebar_new_mail_only");
597 const bool c_sidebar_non_empty_mailbox_only = cs_subset_bool(NeoMutt->sub, "sidebar_non_empty_mailbox_only");
598 struct SbEntry *sbe = NULL;
599
600 struct IndexSharedData *shared = wdata->shared;
601 struct SbEntry **sbep = NULL;
602 ARRAY_FOREACH(sbep, &wdata->entries)
603 {
604 int i = ARRAY_FOREACH_IDX;
605 sbe = *sbep;
606
607 sbe->is_hidden = false;
608
609 if (!sbe->mailbox->visible)
610 {
611 sbe->is_hidden = true;
612 continue;
613 }
614
615 if (shared->mailbox &&
617 {
618 /* Spool directories are always visible */
619 continue;
620 }
621
624 {
625 /* Explicitly asked to be visible */
626 continue;
627 }
628
629 if (c_sidebar_non_empty_mailbox_only && (i != wdata->opn_index) &&
630 (sbe->mailbox->msg_count == 0))
631 {
632 sbe->is_hidden = true;
633 }
634
635 if (c_sidebar_new_mail_only && (i != wdata->opn_index) &&
636 (sbe->mailbox->msg_unread == 0) && (sbe->mailbox->msg_flagged == 0) &&
637 !sbe->mailbox->has_new)
638 {
639 sbe->is_hidden = true;
640 }
641 }
642}
643
657static bool prepare_sidebar(struct SidebarWindowData *wdata, int page_size)
658{
659 if (ARRAY_EMPTY(&wdata->entries) || (page_size <= 0))
660 return false;
661
662 struct SbEntry **sbep = NULL;
663 const bool c_sidebar_new_mail_only = cs_subset_bool(NeoMutt->sub, "sidebar_new_mail_only");
664 const bool c_sidebar_non_empty_mailbox_only = cs_subset_bool(NeoMutt->sub, "sidebar_non_empty_mailbox_only");
665
666 sbep = (wdata->opn_index >= 0) ? ARRAY_GET(&wdata->entries, wdata->opn_index) : NULL;
667 const struct SbEntry *opn_entry = sbep ? *sbep : NULL;
668 sbep = (wdata->hil_index >= 0) ? ARRAY_GET(&wdata->entries, wdata->hil_index) : NULL;
669 const struct SbEntry *hil_entry = sbep ? *sbep : NULL;
670
672 const short c_sidebar_sort_method = cs_subset_sort(NeoMutt->sub, "sidebar_sort_method");
673 sb_sort_entries(wdata, c_sidebar_sort_method);
674
675 if (opn_entry || hil_entry)
676 {
677 ARRAY_FOREACH(sbep, &wdata->entries)
678 {
679 if ((opn_entry == *sbep) && (*sbep)->mailbox->visible)
680 wdata->opn_index = ARRAY_FOREACH_IDX;
681 if ((hil_entry == *sbep) && (*sbep)->mailbox->visible)
682 wdata->hil_index = ARRAY_FOREACH_IDX;
683 }
684 }
685
686 if ((wdata->hil_index < 0) || (hil_entry && hil_entry->is_hidden) ||
687 (c_sidebar_sort_method != wdata->previous_sort))
688 {
689 if (wdata->opn_index >= 0)
690 {
691 wdata->hil_index = wdata->opn_index;
692 }
693 else
694 {
695 wdata->hil_index = 0;
696 /* Note is_hidden will only be set when `$sidebar_new_mail_only` */
697 if ((*ARRAY_GET(&wdata->entries, 0))->is_hidden && !sb_next(wdata))
698 wdata->hil_index = -1;
699 }
700 }
701
702 /* Set the Top and Bottom to frame the wdata->hil_index in groups of page_size */
703
704 /* If `$sidebar_new_mail_only` or `$sidebar_non_empty_mailbox_only` is set,
705 * some entries may be hidden so we need to scan for the framing interval */
706 if (c_sidebar_new_mail_only || c_sidebar_non_empty_mailbox_only)
707 {
708 wdata->top_index = -1;
709 wdata->bot_index = -1;
710 while (wdata->bot_index < wdata->hil_index)
711 {
712 wdata->top_index = wdata->bot_index + 1;
713 int page_entries = 0;
714 while (page_entries < page_size)
715 {
716 wdata->bot_index++;
717 if (wdata->bot_index >= ARRAY_SIZE(&wdata->entries))
718 break;
719 if (!(*ARRAY_GET(&wdata->entries, wdata->bot_index))->is_hidden)
720 page_entries++;
721 }
722 }
723 }
724 else
725 {
726 /* Otherwise we can just calculate the interval */
727 wdata->top_index = (wdata->hil_index / page_size) * page_size;
728 wdata->bot_index = wdata->top_index + page_size - 1;
729 }
730
731 if (wdata->bot_index > (ARRAY_SIZE(&wdata->entries) - 1))
732 wdata->bot_index = ARRAY_SIZE(&wdata->entries) - 1;
733
734 wdata->previous_sort = c_sidebar_sort_method;
735
736 return (wdata->hil_index >= 0);
737}
738
742int sb_recalc(struct MuttWindow *win)
743{
745 struct IndexSharedData *shared = wdata->shared;
746
747 if (ARRAY_EMPTY(&wdata->entries))
748 {
749 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
751 struct MailboxNode *np = NULL;
752 STAILQ_FOREACH(np, &ml, entries)
753 {
754 if (np->mailbox->visible)
755 sb_add_mailbox(wdata, np->mailbox);
756 }
758 }
759
760 if (!prepare_sidebar(wdata, win->state.rows))
761 {
762 win->actions |= WA_REPAINT;
763 return 0;
764 }
765
766 int num_rows = win->state.rows;
767 int num_cols = win->state.cols;
768
769 if (ARRAY_EMPTY(&wdata->entries) || (num_rows <= 0))
770 return 0;
771
772 if (wdata->top_index < 0)
773 return 0;
774
775 int width = num_cols - wdata->divider_width;
776 int row = 0;
777 struct Mailbox *m_cur = shared->mailbox;
778 struct SbEntry **sbep = NULL;
779 ARRAY_FOREACH_FROM(sbep, &wdata->entries, wdata->top_index)
780 {
781 if (row >= num_rows)
782 break;
783
784 if ((*sbep)->is_hidden)
785 continue;
786
787 struct SbEntry *entry = (*sbep);
788 struct Mailbox *m = entry->mailbox;
789
790 const int entryidx = ARRAY_FOREACH_IDX;
791 entry->color = calc_color(m, (entryidx == wdata->opn_index),
792 (entryidx == wdata->hil_index));
793
794 if (m_cur && (m_cur->realpath[0] != '\0') &&
795 mutt_str_equal(m->realpath, m_cur->realpath))
796 {
797 m->msg_unread = m_cur->msg_unread;
798 m->msg_count = m_cur->msg_count;
799 m->msg_flagged = m_cur->msg_flagged;
800 }
801
802 const char *path = mailbox_path(m);
803
804 const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
805 // Try to abbreviate the full path
806 const char *abbr = abbrev_folder(path, c_folder, m->type);
807 if (!abbr)
808 abbr = abbrev_url(path, m->type);
809 const char *short_path = abbr ? abbr : path;
810
811 /* Compute the depth */
812 const char *last_part = abbr;
813 const char *const c_sidebar_delim_chars = cs_subset_string(NeoMutt->sub, "sidebar_delim_chars");
814 entry->depth = calc_path_depth(abbr, c_sidebar_delim_chars, &last_part);
815
816 const bool short_path_is_abbr = (short_path == abbr);
817 const bool c_sidebar_short_path = cs_subset_bool(NeoMutt->sub, "sidebar_short_path");
818 if (c_sidebar_short_path)
819 {
820 short_path = last_part;
821 }
822
823 // Don't indent if we were unable to create an abbreviation.
824 // Otherwise, the full path will be indent, and it looks unusual.
825 const bool c_sidebar_folder_indent = cs_subset_bool(NeoMutt->sub, "sidebar_folder_indent");
826 if (c_sidebar_folder_indent && short_path_is_abbr)
827 {
828 const short c_sidebar_component_depth = cs_subset_number(NeoMutt->sub, "sidebar_component_depth");
829 if (c_sidebar_component_depth > 0)
830 entry->depth -= c_sidebar_component_depth;
831 }
832 else if (!c_sidebar_folder_indent)
833 {
834 entry->depth = 0;
835 }
836
837 mutt_str_copy(entry->box, short_path, sizeof(entry->box));
838 make_sidebar_entry(entry->display, sizeof(entry->display), width, entry, shared);
839 row++;
840 }
841
842 win->actions |= WA_REPAINT;
843 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
844 return 0;
845}
846
863static int draw_divider(struct SidebarWindowData *wdata, struct MuttWindow *win,
864 int num_rows, int num_cols)
865{
866 if ((num_rows < 1) || (num_cols < 1) || (wdata->divider_width > num_cols) ||
867 (wdata->divider_width == 0))
868 {
869 return 0;
870 }
871
872 const int width = wdata->divider_width;
873 const char *const c_sidebar_divider_char = cs_subset_string(NeoMutt->sub, "sidebar_divider_char");
874
879
880 const bool c_sidebar_on_right = cs_subset_bool(NeoMutt->sub, "sidebar_on_right");
881 const int col = c_sidebar_on_right ? 0 : (num_cols - width);
882
883 for (int i = 0; i < num_rows; i++)
884 {
885 mutt_window_move(win, col, i);
886
887 if (wdata->divider_type == SB_DIV_USER)
888 mutt_window_addstr(win, NONULL(c_sidebar_divider_char));
889 else
890 mutt_window_addch(win, '|');
891 }
892
894 return width;
895}
896
907static void fill_empty_space(struct MuttWindow *win, int first_row,
908 int num_rows, int div_width, int num_cols)
909{
910 /* Fill the remaining rows with blank space */
914
915 const bool c_sidebar_on_right = cs_subset_bool(NeoMutt->sub, "sidebar_on_right");
916 if (!c_sidebar_on_right)
917 div_width = 0;
918 for (int r = 0; r < num_rows; r++)
919 {
920 mutt_window_move(win, div_width, first_row + r);
922
923 for (int i = 0; i < num_cols; i++)
924 mutt_window_addch(win, ' ');
925 }
926}
927
931int sb_repaint(struct MuttWindow *win)
932{
934 const bool c_sidebar_on_right = cs_subset_bool(NeoMutt->sub, "sidebar_on_right");
935
936 int row = 0;
937 int num_rows = win->state.rows;
938 int num_cols = win->state.cols;
939
940 if (wdata->top_index >= 0)
941 {
942 int col = 0;
943 if (c_sidebar_on_right)
944 col = wdata->divider_width;
945
946 struct SbEntry **sbep = NULL;
947 ARRAY_FOREACH_FROM(sbep, &wdata->entries, wdata->top_index)
948 {
949 if (row >= num_rows)
950 break;
951
952 if ((*sbep)->is_hidden)
953 continue;
954
955 struct SbEntry *entry = (*sbep);
956 mutt_window_move(win, col, row);
958 mutt_window_printf(win, "%s", entry->display);
959 mutt_refresh();
960 row++;
961 }
962 }
963
964 fill_empty_space(win, row, num_rows - row, wdata->divider_width,
965 num_cols - wdata->divider_width);
966 draw_divider(wdata, win, num_rows, num_cols);
967
968 mutt_debug(LL_DEBUG5, "repaint done\n");
969 return 0;
970}
#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_FOREACH_FROM(elem, head, from)
Iterate from an index to the end.
Definition: array.h:222
#define ARRAY_GET(head, idx)
Return the element at index.
Definition: array.h:108
Color and attribute parsing.
bool simple_color_is_set(enum ColorId cid)
Is the object coloured?
Definition: simple.c:95
struct AttrColor * simple_color_get(enum ColorId cid)
Get the colour of an object by its ID.
Definition: simple.c:74
@ MT_COLOR_SIDEBAR_DIVIDER
Line dividing sidebar from the index/pager.
Definition: color.h:65
@ MT_COLOR_SIDEBAR_NEW
Mailbox with new mail.
Definition: color.h:69
@ MT_COLOR_SIDEBAR_UNREAD
Mailbox with unread mail.
Definition: color.h:72
@ MT_COLOR_INDICATOR
Selected item in list.
Definition: color.h:52
@ MT_COLOR_SIDEBAR_SPOOLFILE
$spool_file (Spool mailbox)
Definition: color.h:71
@ MT_COLOR_SIDEBAR_ORDINARY
Mailbox with no new or flagged messages.
Definition: color.h:70
@ MT_COLOR_SIDEBAR_BACKGROUND
Background colour for the Sidebar.
Definition: color.h:64
@ MT_COLOR_NORMAL
Plain text.
Definition: color.h:57
@ MT_COLOR_SIDEBAR_INDICATOR
Current open mailbox.
Definition: color.h:68
@ MT_COLOR_SIDEBAR_HIGHLIGHT
Select cursor.
Definition: color.h:67
@ MT_COLOR_SIDEBAR_FLAGGED
Mailbox with flagged messages.
Definition: color.h:66
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:169
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
Definition: helpers.c:292
Convenience wrapper for the config headers.
Convenience wrapper for the core headers.
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:861
void mutt_refresh(void)
Force a refresh of the screen.
Definition: curs_lib.c:141
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:914
void mutt_format_s(char *buf, size_t buflen, const char *prec, const char *s)
Format a simple string.
Definition: curs_lib.c:796
Structs that make up an email.
Flags to control mutt_expando_format()
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: format_flags.h:30
#define MUTT_FORMAT_OPTIONAL
Allow optional field processing.
Definition: format_flags.h:33
uint8_t MuttFormatFlags
Flags for mutt_expando_format(), e.g. MUTT_FORMAT_FORCESUBJ.
Definition: format_flags.h:29
static const char * sidebar_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 sidebar - Implements format_t -.
Definition: window.c:348
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:742
#define mutt_debug(LEVEL,...)
Definition: logging2.h:84
int sb_recalc(struct MuttWindow *win)
Recalculate the Sidebar display - Implements MuttWindow::recalc() -.
Definition: window.c:742
int sb_repaint(struct MuttWindow *win)
Repaint the Sidebar display - Implements MuttWindow::repaint() -.
Definition: window.c:931
Convenience wrapper for the gui headers.
GUI manage the main index (list of emails)
struct ListNode * mutt_list_find(const struct ListHead *h, const char *data)
Find a string in a List.
Definition: list.c:102
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:44
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:209
MailboxType
Supported mailbox formats.
Definition: mailbox.h:41
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:51
@ MUTT_POP
'POP3' Mailbox type
Definition: mailbox.h:52
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:50
@ MUTT_MAILBOX_ANY
Match any Mailbox type.
Definition: mailbox.h:42
#define MIN(a, b)
Definition: memory.h:31
struct AttrColor * merged_color_overlay(struct AttrColor *base, struct AttrColor *over)
Combine two colours.
Definition: merged.c:109
Convenience wrapper for the library headers.
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:810
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:798
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:497
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:568
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:653
void mutt_curses_set_color(struct AttrColor *ac)
Set the colour and attributes for text.
Definition: mutt_curses.c:40
struct AttrColor * mutt_curses_set_color_by_id(enum ColorId cid)
Set the colour and attributes by the colour id.
Definition: mutt_curses.c:81
int mutt_window_printf(struct MuttWindow *win, const char *fmt,...)
Write a formatted string to a Window.
Definition: mutt_window.c:425
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:294
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition: mutt_window.c:410
int mutt_window_addch(struct MuttWindow *win, int ch)
Write one character to a Window.
Definition: mutt_window.c:382
#define WA_REPAINT
Redraw the contents of the Window.
Definition: mutt_window.h:111
Some miscellaneous functions.
void neomutt_mailboxlist_clear(struct MailboxList *ml)
Free a Mailbox List.
Definition: neomutt.c:141
size_t neomutt_mailboxlist_get_all(struct MailboxList *head, struct NeoMutt *n, enum MailboxType type)
Get a List of all Mailboxes.
Definition: neomutt.c:164
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
bool sb_next(struct SidebarWindowData *wdata)
Find the next unhidden Mailbox.
Definition: functions.c:47
GUI display the mailboxes in a side panel.
@ SB_DIV_USER
User configured using $sidebar_divider_char.
Definition: private.h:56
struct ListHead SidebarPinned
List of mailboxes to always display in the sidebar.
Definition: sidebar.c:43
void sb_add_mailbox(struct SidebarWindowData *wdata, struct Mailbox *m)
Add a Mailbox to the Sidebar.
Definition: sidebar.c:88
void sb_sort_entries(struct SidebarWindowData *wdata, enum SortType sort)
Sort the Sidebar entries.
Definition: sort.c:177
struct SidebarWindowData * sb_wdata_get(struct MuttWindow *win)
Get the Sidebar data for this window.
Definition: wdata.c:73
static const char * abbrev_url(const char *mbox, enum MailboxType type)
Abbreviate a url-style Mailbox path.
Definition: window.c:202
static void fill_empty_space(struct MuttWindow *win, int first_row, int num_rows, int div_width, int num_cols)
Wipe the remaining Sidebar space.
Definition: window.c:907
static void update_entries_visibility(struct SidebarWindowData *wdata)
Should a SbEntry be displayed in the sidebar?
Definition: window.c:593
static const char * abbrev_folder(const char *mbox, const char *folder, enum MailboxType type)
Abbreviate a Mailbox path using a folder.
Definition: window.c:138
static size_t add_indent(char *buf, size_t buflen, const struct SbEntry *sbe)
Generate the needed indentation.
Definition: window.c:231
static int calc_path_depth(const char *mbox, const char *delims, const char **last_part)
Calculate the depth of a Mailbox path.
Definition: window.c:312
static bool prepare_sidebar(struct SidebarWindowData *wdata, int page_size)
Prepare the list of SbEntry's for the sidebar display.
Definition: window.c:657
static int imap_is_prefix(const char *folder, const char *mbox)
Check if folder matches the beginning of mbox.
Definition: window.c:99
static int draw_divider(struct SidebarWindowData *wdata, struct MuttWindow *win, int num_rows, int num_cols)
Draw a line between the sidebar and the rest of neomutt.
Definition: window.c:863
static void make_sidebar_entry(char *buf, size_t buflen, int width, struct SbEntry *sbe, struct IndexSharedData *shared)
Turn mailbox data into a sidebar string.
Definition: window.c:554
static struct AttrColor * calc_color(const struct Mailbox *m, bool current, bool highlight)
Calculate the colour of a Sidebar row.
Definition: window.c:249
#define NONULL(x)
Definition: string2.h:37
A curses colour and its attributes.
Definition: attr.h:35
Data shared between Index, Pager and Sidebar.
Definition: shared_data.h:37
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:41
List of Mailboxes.
Definition: mailbox.h:152
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:153
A mailbox.
Definition: mailbox.h:79
int vcount
The number of virtual messages.
Definition: mailbox.h:99
bool has_new
Mailbox has new mail.
Definition: mailbox.h:85
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:81
int msg_new
Number of new messages.
Definition: mailbox.h:92
int msg_count
Total number of messages.
Definition: mailbox.h:88
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
char * name
A short name for the Mailbox.
Definition: mailbox.h:82
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:93
bool visible
True if a result of "mailboxes".
Definition: mailbox.h:130
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:90
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:94
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
void * wdata
Private data.
Definition: mutt_window.h:145
WindowActionFlags actions
Actions to be performed, e.g. WA_RECALC.
Definition: mutt_window.h:132
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
Info about folders in the sidebar.
Definition: private.h:41
int depth
Indentation depth.
Definition: private.h:44
char display[256]
Formatted string to display.
Definition: private.h:43
struct AttrColor * color
Colour to use.
Definition: private.h:47
struct Mailbox * mailbox
Mailbox this represents.
Definition: private.h:45
bool is_hidden
Don't show, e.g. $sidebar_new_mail_only.
Definition: private.h:46
char box[256]
Mailbox path (possibly abbreviated)
Definition: private.h:42
Data passed to sidebar_format_str()
Definition: window.c:88
struct IndexSharedData * shared
Shared Index Data.
Definition: window.c:90
struct SbEntry * entry
Info about a folder.
Definition: window.c:89
Sidebar private Window data -.
Definition: private.h:64
short previous_sort
Old $sidebar_sort_method
Definition: private.h:74
int top_index
First mailbox visible in sidebar.
Definition: private.h:69
short divider_width
Width of the divider in screen columns.
Definition: private.h:76
int bot_index
Last mailbox visible in sidebar.
Definition: private.h:72
int hil_index
Highlighted mailbox.
Definition: private.h:71
enum DivType divider_type
Type of divider to use, e.g. SB_DIV_ASCII.
Definition: private.h:75
struct IndexSharedData * shared
Shared Index Data.
Definition: private.h:66
int opn_index
Current (open) mailbox.
Definition: private.h:70
struct MuttWindow * win
Sidebar Window.
Definition: private.h:65
struct SbEntryArray entries
Items to display in the sidebar.
Definition: private.h:67
A parsed URL proto://user:password@host:port/path?a=1&b=2
Definition: url.h:69
char * user
Username.
Definition: url.h:71
char * host
Host.
Definition: url.h:73
char * path
Path.
Definition: url.h:75
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
short rows
Number of rows, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:61
struct Url * url_parse(const char *src)
Fill in Url.
Definition: url.c:238
void url_free(struct Url **ptr)
Free the contents of a URL.
Definition: url.c:123