NeoMutt  2024-02-01-25-ga71e95
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
lib.h File Reference

Select a Mailbox from a list. More...

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <sys/types.h>
#include "mutt/lib.h"
#include "complete/lib.h"
+ Include dependency graph for lib.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  Folder
 A folder/dir in the browser. More...
 
struct  FolderFile
 Browser entry representing a folder/dir. More...
 
struct  BrowserState
 State of the file/mailbox browser. More...
 

Macros

#define MUTT_SEL_NO_FLAGS   0
 No flags are set.
 
#define MUTT_SEL_MAILBOX   (1 << 0)
 Select a mailbox.
 
#define MUTT_SEL_MULTI   (1 << 1)
 Multi-selection is enabled.
 
#define MUTT_SEL_FOLDER   (1 << 2)
 Select a local directory.
 

Typedefs

typedef uint8_t SelectFileFlags
 Flags for mutt_select_file(), e.g. MUTT_SEL_MAILBOX.
 

Functions

 ARRAY_HEAD (BrowserEntryArray, struct FolderFile)
 
void dlg_browser (struct Buffer *file, SelectFileFlags flags, struct Mailbox *m, char ***files, int *numfiles)
 Let the user select a file -.
 
void mutt_browser_select_dir (const char *f)
 Remember the last directory selected.
 
void mutt_browser_cleanup (void)
 Clean up working Buffers.
 
void browser_sort (struct BrowserState *state)
 Sort the entries in the browser.
 
void browser_add_folder (const struct Menu *menu, struct BrowserState *state, const char *name, const char *desc, const struct stat *st, struct Mailbox *m, void *data)
 Add a folder to the browser list.
 
void browser_highlight_default (struct BrowserState *state, struct Menu *menu)
 Decide which browser item should be highlighted.
 
int examine_directory (struct Mailbox *m, struct Menu *menu, struct BrowserState *state, const char *d, const char *prefix)
 Get list of all files/newsgroups with mask.
 
int examine_mailboxes (struct Mailbox *m, struct Menu *menu, struct BrowserState *state)
 Get list of mailboxes/subscribed newsgroups.
 
void init_menu (struct BrowserState *state, struct Menu *menu, struct Mailbox *m, struct MuttWindow *sbar)
 Set up a new menu.
 
void init_state (struct BrowserState *state, struct Menu *menu)
 Initialise a browser state.
 
bool link_is_dir (const char *folder, const char *path)
 Does this symlink point to a directory?
 
void destroy_state (struct BrowserState *state)
 Free the BrowserState.
 
void dump_state (struct BrowserState *state)
 

Variables

struct Buffer LastDir
 Browser: previous selected directory.
 
struct Buffer LastDirBackup
 Browser: backup copy of the current directory.
 
const struct CompleteOps CompleteFileOps
 Auto-Completion of Files.
 
const struct CompleteOps CompleteMailboxOps
 Auto-Completion of Files / Mailboxes.
 

Detailed Description

Select a Mailbox from a list.

Authors
  • Richard Russon

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file lib.h.

Macro Definition Documentation

◆ MUTT_SEL_NO_FLAGS

#define MUTT_SEL_NO_FLAGS   0

No flags are set.

Definition at line 57 of file lib.h.

◆ MUTT_SEL_MAILBOX

#define MUTT_SEL_MAILBOX   (1 << 0)

Select a mailbox.

Definition at line 58 of file lib.h.

◆ MUTT_SEL_MULTI

#define MUTT_SEL_MULTI   (1 << 1)

Multi-selection is enabled.

Definition at line 59 of file lib.h.

◆ MUTT_SEL_FOLDER

#define MUTT_SEL_FOLDER   (1 << 2)

Select a local directory.

Definition at line 60 of file lib.h.

Typedef Documentation

◆ SelectFileFlags

typedef uint8_t SelectFileFlags

Flags for mutt_select_file(), e.g. MUTT_SEL_MAILBOX.

Definition at line 56 of file lib.h.

Function Documentation

◆ ARRAY_HEAD()

ARRAY_HEAD ( BrowserEntryArray  ,
struct FolderFile   
)

◆ mutt_browser_select_dir()

void mutt_browser_select_dir ( const char *  f)

Remember the last directory selected.

Parameters
fDirectory name to save

This function helps the browser to know which directory has been selected. It should be called anywhere a confirm hit is done to open a new directory/file which is a maildir/mbox.

We could check if the sort method is appropriate with this feature.

Definition at line 1210 of file dlg_browser.c.

1211{
1212 init_lastdir();
1213
1215
1216 /* Method that will fetch the parent path depending on the type of the path. */
1217 char buf[PATH_MAX] = { 0 };
1218 mutt_get_parent_path(buf_string(&LastDirBackup), buf, sizeof(buf));
1219 buf_strcpy(&LastDir, buf);
1220}
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:412
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:97
static void init_lastdir(void)
Initialise the browser directories.
Definition: dlg_browser.c:145
struct Buffer LastDir
Browser: previous selected directory.
Definition: dlg_browser.c:136
struct Buffer LastDirBackup
Browser: backup copy of the current directory.
Definition: dlg_browser.c:138
#define PATH_MAX
Definition: mutt.h:42
void mutt_get_parent_path(const char *path, char *buf, size_t buflen)
Find the parent of a path (or mailbox)
Definition: muttlib.c:1514
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_browser_cleanup()

void mutt_browser_cleanup ( void  )

Clean up working Buffers.

Definition at line 159 of file dlg_browser.c.

160{
163}
void buf_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:394
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ browser_sort()

void browser_sort ( struct BrowserState state)

Sort the entries in the browser.

Parameters
stateBrowser state

Call to qsort using browser_sort_helper function. Some specific sort methods are not used via NNTP.

Definition at line 186 of file sort.c.

187{
188 const enum SortType c_sort_browser = cs_subset_sort(NeoMutt->sub, "sort_browser");
189 switch (c_sort_browser & SORT_MASK)
190 {
191 case SORT_SIZE:
192 case SORT_DATE:
193 if (OptNews)
194 return;
196 default:
197 break;
198 }
199
200 sort_t f = NULL;
201 switch (c_sort_browser & SORT_MASK)
202 {
203 case SORT_COUNT:
205 break;
206 case SORT_DATE:
208 break;
209 case SORT_DESC:
211 break;
212 case SORT_SIZE:
214 break;
215 case SORT_UNREAD:
217 break;
218 case SORT_SUBJECT:
220 break;
221 default:
222 case SORT_ORDER:
224 break;
225 }
226
227 struct CompareData cd = {
228 .sort_fn = f,
229 .sort_reverse = c_sort_browser & SORT_REVERSE,
230 .sort_dirs_first = cs_subset_bool(NeoMutt->sub, "browser_sort_dirs_first"),
231 };
232
233 ARRAY_SORT(&state->entry, browser_sort_helper, &cd);
234}
#define ARRAY_SORT(head, fn, sdata)
Sort an array.
Definition: array.h:279
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
Definition: helpers.c:267
bool OptNews
(pseudo) used to change reader mode
Definition: globals.c:70
static int browser_sort_desc(const void *a, const void *b, void *sdata)
Compare two browser entries by their descriptions - Implements sort_t -.
Definition: sort.c:84
static int browser_sort_date(const void *a, const void *b, void *sdata)
Compare two browser entries by their date - Implements sort_t -.
Definition: sort.c:95
static int browser_sort_count(const void *a, const void *b, void *sdata)
Compare two browser entries by their message count - Implements sort_t -.
Definition: sort.c:117
static int browser_sort_size(const void *a, const void *b, void *sdata)
Compare two browser entries by their size - Implements sort_t -.
Definition: sort.c:106
static int browser_sort_count_new(const void *a, const void *b, void *sdata)
Compare two browser entries by their new count - Implements sort_t -.
Definition: sort.c:136
static int browser_sort_order(const void *a, const void *b, void *sdata)
Compare two browser entries by their order - Implements sort_t -.
Definition: sort.c:73
static int browser_sort_helper(const void *a, const void *b, void *sdata)
Helper to sort the items in the browser - Implements sort_t -.
Definition: sort.c:159
static int browser_sort_subject(const void *a, const void *b, void *sdata)
Compare two browser entries by their subject - Implements sort_t -.
Definition: sort.c:55
#define FALLTHROUGH
Definition: lib.h:111
int(* sort_t)(const void *a, const void *b, void *sdata)
Definition: qsort_r.h:41
#define SORT_MASK
Mask for the sort id.
Definition: sort2.h:70
SortType
Methods for sorting.
Definition: sort2.h:34
@ SORT_SUBJECT
Sort by the email's subject.
Definition: sort2.h:38
@ SORT_ORDER
Sort by the order the messages appear in the mailbox.
Definition: sort2.h:40
@ SORT_SIZE
Sort by the size of the email.
Definition: sort2.h:36
@ SORT_DESC
Sort by the folder's description.
Definition: sort2.h:55
@ SORT_DATE
Sort by the date the email was sent.
Definition: sort2.h:35
@ SORT_COUNT
Sort by number of emails in a folder.
Definition: sort2.h:50
@ SORT_UNREAD
Sort by the number of unread emails.
Definition: sort2.h:51
#define SORT_REVERSE
Reverse the order of the sort.
Definition: sort2.h:71
struct BrowserEntryArray entry
Array of files / dirs / mailboxes.
Definition: lib.h:115
Private data for browser_sort_helper()
Definition: sort.c:46
sort_t sort_fn
Function to perform $browser_sort.
Definition: sort.c:49
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ browser_add_folder()

void browser_add_folder ( const struct Menu menu,
struct BrowserState state,
const char *  name,
const char *  desc,
const struct stat *  st,
struct Mailbox m,
void *  data 
)

Add a folder to the browser list.

Parameters
menuMenu to use
stateBrowser state
nameName of folder
descDescription of folder
ststat info for the folder
mMailbox
dataData to associate with the folder

Definition at line 578 of file dlg_browser.c.

581{
582 if ((!menu || state->is_mailbox_list) && m && !m->visible)
583 {
584 return;
585 }
586
587 struct FolderFile ff = { 0 };
588
589 if (st)
590 {
591 ff.mode = st->st_mode;
592 ff.mtime = st->st_mtime;
593 ff.size = st->st_size;
594 ff.gid = st->st_gid;
595 ff.uid = st->st_uid;
596 ff.nlink = st->st_nlink;
597 ff.local = true;
598 }
599 else
600 {
601 ff.local = false;
602 }
603
604 if (m)
605 {
606 ff.has_mailbox = true;
607 ff.gen = m->gen;
608 ff.has_new_mail = m->has_new;
609 ff.msg_count = m->msg_count;
610 ff.msg_unread = m->msg_unread;
611 ff.notify_user = m->notify_user;
613 }
614
615 ff.name = mutt_str_dup(name);
616 ff.desc = mutt_str_dup(desc ? desc : name);
617 ff.imap = false;
618 if (OptNews)
619 ff.nd = data;
620
621 ARRAY_ADD(&state->entry, ff);
622}
#define ARRAY_ADD(head, elem)
Add an element at the end of the array.
Definition: array.h:156
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
bool is_mailbox_list
Viewing mailboxes.
Definition: lib.h:118
Browser entry representing a folder/dir.
Definition: lib.h:78
bool imap
This is an IMAP folder.
Definition: lib.h:95
bool has_mailbox
This is a mailbox.
Definition: lib.h:98
char * name
Name of file/dir/mailbox.
Definition: lib.h:86
uid_t uid
File's User ID.
Definition: lib.h:82
gid_t gid
File's Group ID.
Definition: lib.h:83
bool has_new_mail
true if mailbox has "new mail"
Definition: lib.h:89
bool poll_new_mail
Check mailbox for new mail.
Definition: lib.h:101
bool notify_user
User will be notified of new mail.
Definition: lib.h:100
nlink_t nlink
Number of hard links.
Definition: lib.h:84
char * desc
Description of mailbox.
Definition: lib.h:87
struct NntpMboxData * nd
Extra NNTP data.
Definition: lib.h:103
off_t size
File size.
Definition: lib.h:80
int gen
Unique id, used for (un)sorting.
Definition: lib.h:105
time_t mtime
Modification time.
Definition: lib.h:81
int msg_count
total number of messages
Definition: lib.h:90
mode_t mode
File permissions.
Definition: lib.h:79
int msg_unread
number of unread messages
Definition: lib.h:91
bool has_new
Mailbox has new mail.
Definition: mailbox.h:85
int msg_count
Total number of messages.
Definition: mailbox.h:88
bool poll_new_mail
Check for new mail.
Definition: mailbox.h:115
bool notify_user
Notify the user of new mail.
Definition: mailbox.h:113
bool visible
True if a result of "mailboxes".
Definition: mailbox.h:130
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
int gen
Generation number, for sorting.
Definition: mailbox.h:147
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ browser_highlight_default()

void browser_highlight_default ( struct BrowserState state,
struct Menu menu 
)

Decide which browser item should be highlighted.

Parameters
stateBrowser state
menuCurrent Menu

This function takes a menu and a state and defines the current entry that should be highlighted.

Definition at line 940 of file dlg_browser.c.

941{
942 menu->top = 0;
943 /* Reset menu position to 1.
944 * We do not risk overflow as the init_menu function changes
945 * current if it is bigger than state->entrylen. */
946 if (!ARRAY_EMPTY(&state->entry) &&
947 (mutt_str_equal(ARRAY_FIRST(&state->entry)->desc, "..") ||
948 mutt_str_equal(ARRAY_FIRST(&state->entry)->desc, "../")))
949 {
950 /* Skip the first entry, unless there's only one entry. */
951 menu_set_index(menu, (menu->max > 1));
952 }
953 else
954 {
955 menu_set_index(menu, 0);
956 }
957}
#define ARRAY_FIRST(head)
Convenience method to get the first element.
Definition: array.h:135
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:74
MenuRedrawFlags menu_set_index(struct Menu *menu, int index)
Set the current selection in the Menu.
Definition: menu.c:173
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:709
int top
Entry that is the top of the current page.
Definition: lib.h:80
int max
Number of entries in the menu.
Definition: lib.h:71
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ examine_directory()

int examine_directory ( struct Mailbox m,
struct Menu menu,
struct BrowserState state,
const char *  dirname,
const char *  prefix 
)

Get list of all files/newsgroups with mask.

Parameters
mMailbox
menuCurrent Menu
stateState of browser
dirnameDirectory
prefixFiles/newsgroups must match this prefix
Return values
0Success
-1Error

Definition at line 652 of file dlg_browser.c.

654{
655 int rc = -1;
656 struct Buffer *buf = buf_pool_get();
657 if (OptNews)
658 {
660
661 init_state(state, menu);
662
663 const struct Regex *c_mask = cs_subset_regex(NeoMutt->sub, "mask");
664 for (unsigned int i = 0; i < adata->groups_num; i++)
665 {
666 struct NntpMboxData *mdata = adata->groups_list[i];
667 if (!mdata)
668 continue;
669 if (prefix && *prefix && !mutt_str_startswith(mdata->group, prefix))
670 continue;
671 if (!mutt_regex_match(c_mask, mdata->group))
672 {
673 continue;
674 }
675 browser_add_folder(menu, state, mdata->group, NULL, NULL, NULL, mdata);
676 }
677 }
678 else
679 {
680 struct stat st = { 0 };
681 DIR *dir = NULL;
682 struct dirent *de = NULL;
683
684 while (stat(dirname, &st) == -1)
685 {
686 if (errno == ENOENT)
687 {
688 /* The last used directory is deleted, try to use the parent dir. */
689 char *c = strrchr(dirname, '/');
690
691 if (c && (c > dirname))
692 {
693 *c = '\0';
694 continue;
695 }
696 }
697 mutt_perror("%s", dirname);
698 goto ed_out;
699 }
700
701 if (!S_ISDIR(st.st_mode))
702 {
703 mutt_error(_("%s is not a directory"), dirname);
704 goto ed_out;
705 }
706
707 if (m)
709
710 dir = mutt_file_opendir(dirname, MUTT_OPENDIR_NONE);
711 if (!dir)
712 {
713 mutt_perror("%s", dirname);
714 goto ed_out;
715 }
716
717 init_state(state, menu);
718
719 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
721
722 const struct Regex *c_mask = cs_subset_regex(NeoMutt->sub, "mask");
723 while ((de = readdir(dir)))
724 {
725 if (mutt_str_equal(de->d_name, "."))
726 continue; /* we don't need . */
727
728 if (prefix && *prefix && !mutt_str_startswith(de->d_name, prefix))
729 {
730 continue;
731 }
732 if (!mutt_regex_match(c_mask, de->d_name))
733 {
734 continue;
735 }
736
737 buf_concat_path(buf, dirname, de->d_name);
738 if (lstat(buf_string(buf), &st) == -1)
739 continue;
740
741 /* No size for directories or symlinks */
742 if (S_ISDIR(st.st_mode) || S_ISLNK(st.st_mode))
743 st.st_size = 0;
744 else if (!S_ISREG(st.st_mode))
745 continue;
746
747 struct MailboxNode *np = NULL;
748 STAILQ_FOREACH(np, &ml, entries)
749 {
751 break;
752 }
753
754 if (np && m && m->poll_new_mail && mutt_str_equal(np->mailbox->realpath, m->realpath))
755 {
756 np->mailbox->msg_count = m->msg_count;
757 np->mailbox->msg_unread = m->msg_unread;
758 }
759 browser_add_folder(menu, state, de->d_name, NULL, &st, np ? np->mailbox : NULL, NULL);
760 }
762 closedir(dir);
763 }
764 browser_sort(state);
765 rc = 0;
766ed_out:
767 buf_pool_release(&buf);
768 return rc;
769}
void browser_sort(struct BrowserState *state)
Sort the entries in the browser.
Definition: sort.c:186
size_t buf_concat_path(struct Buffer *buf, const char *dir, const char *fname)
Join a directory name and a filename.
Definition: buffer.c:526
const struct Regex * cs_subset_regex(const struct ConfigSubset *sub, const char *name)
Get a regex config item by name.
Definition: helpers.c:218
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:211
@ MUTT_MAILBOX_ANY
Match any Mailbox type.
Definition: mailbox.h:42
void init_state(struct BrowserState *state, struct Menu *menu)
Initialise a browser state.
Definition: dlg_browser.c:629
void browser_add_folder(const struct Menu *menu, struct BrowserState *state, const char *name, const char *desc, const struct stat *st, struct Mailbox *m, void *data)
Add a folder to the browser list.
Definition: dlg_browser.c:578
DIR * mutt_file_opendir(const char *path, enum MuttOpenDirMode mode)
Open a directory.
Definition: file.c:636
@ MUTT_OPENDIR_NONE
Plain opendir()
Definition: file.h:74
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_perror(...)
Definition: logging2.h:93
#define _(a)
Definition: message.h:28
bool mutt_regex_match(const struct Regex *regex, const char *str)
Shorthand to mutt_regex_capture()
Definition: regex.c:639
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:230
int mutt_mailbox_check(struct Mailbox *m_cur, CheckStatsFlags flags)
Check all all Mailboxes for new mail.
Definition: mutt_mailbox.c:168
#define MUTT_MAILBOX_CHECK_NO_FLAGS
No flags are set.
Definition: mxapi.h:53
void neomutt_mailboxlist_clear(struct MailboxList *ml)
Free a Mailbox List.
Definition: neomutt.c:163
size_t neomutt_mailboxlist_get_all(struct MailboxList *head, struct NeoMutt *n, enum MailboxType type)
Get a List of all Mailboxes.
Definition: neomutt.c:186
struct NntpAccountData * CurrentNewsSrv
Current NNTP news server.
Definition: nntp.c:77
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 STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
void * adata
Private data (for Mailbox backends)
Definition: account.h:42
String manipulation buffer.
Definition: buffer.h:36
List of Mailboxes.
Definition: mailbox.h:154
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:155
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:81
void * mdata
Driver specific data.
Definition: mailbox.h:132
NNTP-specific Account data -.
Definition: adata.h:36
unsigned int groups_num
Definition: adata.h:58
void ** groups_list
Definition: adata.h:60
NNTP-specific Mailbox data -.
Definition: mdata.h:34
struct NntpAccountData * adata
Definition: mdata.h:48
Cached regular expression.
Definition: regex3.h:85
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ examine_mailboxes()

int examine_mailboxes ( struct Mailbox m,
struct Menu menu,
struct BrowserState state 
)

Get list of mailboxes/subscribed newsgroups.

Parameters
mMailbox
menuCurrent menu
stateState of browser
Return values
0Success
-1Error

Definition at line 779 of file dlg_browser.c.

780{
781 struct stat st = { 0 };
782 struct Buffer *md = NULL;
783 struct Buffer *mailbox = NULL;
784
785 if (OptNews)
786 {
788
789 init_state(state, menu);
790
791 const bool c_show_only_unread = cs_subset_bool(NeoMutt->sub, "show_only_unread");
792 for (unsigned int i = 0; i < adata->groups_num; i++)
793 {
794 struct NntpMboxData *mdata = adata->groups_list[i];
795 if (mdata && (mdata->has_new_mail ||
796 (mdata->subscribed && (mdata->unread || !c_show_only_unread))))
797 {
798 browser_add_folder(menu, state, mdata->group, NULL, NULL, NULL, mdata);
799 }
800 }
801 }
802 else
803 {
804 init_state(state, menu);
805
807 return -1;
808 mailbox = buf_pool_get();
809 md = buf_pool_get();
810
812
813 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
815 struct MailboxNode *np = NULL;
816 const bool c_browser_abbreviate_mailboxes = cs_subset_bool(NeoMutt->sub, "browser_abbreviate_mailboxes");
817
818 STAILQ_FOREACH(np, &ml, entries)
819 {
820 if (!np->mailbox)
821 continue;
822
823 if (m && m->poll_new_mail && mutt_str_equal(np->mailbox->realpath, m->realpath))
824 {
825 np->mailbox->msg_count = m->msg_count;
826 np->mailbox->msg_unread = m->msg_unread;
827 }
828
830 if (c_browser_abbreviate_mailboxes)
832
833 switch (np->mailbox->type)
834 {
835 case MUTT_IMAP:
836 case MUTT_POP:
838 np->mailbox->name, NULL, np->mailbox, NULL);
839 continue;
840 case MUTT_NOTMUCH:
841 case MUTT_NNTP:
842 browser_add_folder(menu, state, mailbox_path(np->mailbox),
843 np->mailbox->name, NULL, np->mailbox, NULL);
844 continue;
845 default: /* Continue */
846 break;
847 }
848
849 if (lstat(mailbox_path(np->mailbox), &st) == -1)
850 continue;
851
852 if ((!S_ISREG(st.st_mode)) && (!S_ISDIR(st.st_mode)) && (!S_ISLNK(st.st_mode)))
853 continue;
854
855 if (np->mailbox->type == MUTT_MAILDIR)
856 {
857 struct stat st2 = { 0 };
858
859 buf_printf(md, "%s/new", mailbox_path(np->mailbox));
860 if (stat(buf_string(md), &st) < 0)
861 st.st_mtime = 0;
862 buf_printf(md, "%s/cur", mailbox_path(np->mailbox));
863 if (stat(buf_string(md), &st2) < 0)
864 st2.st_mtime = 0;
865 if (st2.st_mtime > st.st_mtime)
866 st.st_mtime = st2.st_mtime;
867 }
868
869 browser_add_folder(menu, state, buf_string(mailbox), np->mailbox->name,
870 &st, np->mailbox, NULL);
871 }
873 }
874 browser_sort(state);
875
876 buf_pool_release(&mailbox);
877 buf_pool_release(&md);
878 return 0;
879}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:178
@ 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_MAILDIR
'Maildir' Mailbox type
Definition: mailbox.h:48
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:557
#define TAILQ_EMPTY(head)
Definition: queue.h:721
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
char * name
A short name for the Mailbox.
Definition: mailbox.h:82
struct AccountList accounts
List of all Accounts.
Definition: neomutt.h:46
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ init_menu()

void init_menu ( struct BrowserState state,
struct Menu menu,
struct Mailbox m,
struct MuttWindow sbar 
)

Set up a new menu.

Parameters
stateBrowser state
menuCurrent menu
mMailbox
sbarStatus bar

Definition at line 966 of file dlg_browser.c.

968{
969 char title[256] = { 0 };
970 menu->max = ARRAY_SIZE(&state->entry);
971
972 int index = menu_get_index(menu);
973 if (index >= menu->max)
974 menu_set_index(menu, menu->max - 1);
975 if (index < 0)
976 menu_set_index(menu, 0);
977 if (menu->top > index)
978 menu->top = 0;
979
980 menu->num_tagged = 0;
981
982 if (OptNews)
983 {
984 if (state->is_mailbox_list)
985 {
986 snprintf(title, sizeof(title), _("Subscribed newsgroups"));
987 }
988 else
989 {
990 snprintf(title, sizeof(title), _("Newsgroups on server [%s]"),
992 }
993 }
994 else
995 {
996 if (state->is_mailbox_list)
997 {
998 snprintf(title, sizeof(title), _("Mailboxes [%d]"),
1000 }
1001 else
1002 {
1003 struct Buffer *path = buf_pool_get();
1004 buf_copy(path, &LastDir);
1005 buf_pretty_mailbox(path);
1006 const struct Regex *c_mask = cs_subset_regex(NeoMutt->sub, "mask");
1007 const bool c_imap_list_subscribed = cs_subset_bool(NeoMutt->sub, "imap_list_subscribed");
1008 if (state->imap_browse && c_imap_list_subscribed)
1009 {
1010 snprintf(title, sizeof(title), _("Subscribed [%s], File mask: %s"),
1011 buf_string(path), NONULL(c_mask ? c_mask->pattern : NULL));
1012 }
1013 else
1014 {
1015 snprintf(title, sizeof(title), _("Directory [%s], File mask: %s"),
1016 buf_string(path), NONULL(c_mask ? c_mask->pattern : NULL));
1017 }
1018 buf_pool_release(&path);
1019 }
1020 }
1021 sbar_set_title(sbar, title);
1022
1023 /* Browser tracking feature.
1024 * The goal is to highlight the good directory if LastDir is the parent dir
1025 * of LastDirBackup (this occurs mostly when one hit "../"). It should also work
1026 * properly when the user is in examine_mailboxes-mode. */
1028 {
1029 char target_dir[PATH_MAX] = { 0 };
1030
1031 /* Check what kind of dir LastDirBackup is. */
1033 {
1034 mutt_str_copy(target_dir, buf_string(&LastDirBackup), sizeof(target_dir));
1035 imap_clean_path(target_dir, sizeof(target_dir));
1036 }
1037 else
1038 {
1039 mutt_str_copy(target_dir, strrchr(buf_string(&LastDirBackup), '/') + 1,
1040 sizeof(target_dir));
1041 }
1042
1043 /* If we get here, it means that LastDir is the parent directory of
1044 * LastDirBackup. I.e., we're returning from a subdirectory, and we want
1045 * to position the cursor on the directory we're returning from. */
1046 bool matched = false;
1047 struct FolderFile *ff = NULL;
1048 ARRAY_FOREACH(ff, &state->entry)
1049 {
1050 if (mutt_str_equal(ff->name, target_dir))
1051 {
1052 menu_set_index(menu, ARRAY_FOREACH_IDX);
1053 matched = true;
1054 break;
1055 }
1056 }
1057 if (!matched)
1058 browser_highlight_default(state, menu);
1059 }
1060 else
1061 {
1062 browser_highlight_default(state, menu);
1063 }
1064
1066}
#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
size_t buf_copy(struct Buffer *dst, const struct Buffer *src)
Copy a Buffer's contents to another Buffer.
Definition: buffer.c:618
void browser_highlight_default(struct BrowserState *state, struct Menu *menu)
Decide which browser item should be highlighted.
Definition: dlg_browser.c:940
enum MailboxType imap_path_probe(const char *path, const struct stat *st)
Is this an IMAP Mailbox? - Implements MxOps::path_probe() -.
Definition: imap.c:2342
void imap_clean_path(char *path, size_t plen)
Cleans an IMAP path using imap_fix_path.
Definition: util.c:189
#define MENU_REDRAW_FULL
Redraw everything.
Definition: lib.h:59
void menu_queue_redraw(struct Menu *menu, MenuRedrawFlags redraw)
Queue a request for a redraw.
Definition: menu.c:183
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:159
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:630
void sbar_set_title(struct MuttWindow *win, const char *title)
Set the title for the Simple Bar.
Definition: sbar.c:227
#define NONULL(x)
Definition: string2.h:37
bool imap_browse
IMAP folder.
Definition: lib.h:116
char host[128]
Server to login to.
Definition: connaccount.h:54
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:49
int num_tagged
Number of tagged entries.
Definition: lib.h:83
struct Connection * conn
Connection to NNTP Server.
Definition: adata.h:62
char * pattern
printable version
Definition: regex3.h:86
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ init_state()

void init_state ( struct BrowserState state,
struct Menu menu 
)

Initialise a browser state.

Parameters
stateBrowserState to initialise
menuCurrent menu

Definition at line 629 of file dlg_browser.c.

630{
631 ARRAY_INIT(&state->entry);
632 ARRAY_RESERVE(&state->entry, 256);
633 state->imap_browse = false;
634
635 if (menu)
636 {
637 menu->mdata = &state->entry;
638 menu->mdata_free = NULL; // Menu doesn't own the data
639 }
640}
#define ARRAY_RESERVE(head, num)
Reserve memory for the array.
Definition: array.h:189
#define ARRAY_INIT(head)
Initialize an array.
Definition: array.h:65
void(* mdata_free)(struct Menu *menu, void **ptr)
Definition: lib.h:149
void * mdata
Private data.
Definition: lib.h:135
+ Here is the caller graph for this function:

◆ link_is_dir()

bool link_is_dir ( const char *  folder,
const char *  path 
)

Does this symlink point to a directory?

Parameters
folderFolder
pathLink name
Return values
trueLinks to a directory
falseOtherwise

Definition at line 172 of file dlg_browser.c.

173{
174 struct stat st = { 0 };
175 bool rc = false;
176
177 struct Buffer *fullpath = buf_pool_get();
178 buf_concat_path(fullpath, folder, path);
179
180 if (stat(buf_string(fullpath), &st) == 0)
181 rc = S_ISDIR(st.st_mode);
182
183 buf_pool_release(&fullpath);
184
185 return rc;
186}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ destroy_state()

void destroy_state ( struct BrowserState state)

Free the BrowserState.

Parameters
stateState to free

Frees up the memory allocated for the local-global variables.

Definition at line 137 of file functions.c.

138{
139 struct FolderFile *ff = NULL;
140 ARRAY_FOREACH(ff, &state->entry)
141 {
142 FREE(&ff->name);
143 FREE(&ff->desc);
144 }
145 ARRAY_FREE(&state->entry);
146 FREE(&state->folder);
147}
#define ARRAY_FREE(head)
Release all memory.
Definition: array.h:204
#define FREE(x)
Definition: memory.h:45
char * folder
Folder name.
Definition: lib.h:117
+ Here is the caller graph for this function:

◆ dump_state()

void dump_state ( struct BrowserState state)

Variable Documentation

◆ LastDir

struct Buffer LastDir
extern

Browser: previous selected directory.

Definition at line 136 of file dlg_browser.c.

◆ LastDirBackup

struct Buffer LastDirBackup
extern

Browser: backup copy of the current directory.

Definition at line 138 of file dlg_browser.c.

◆ CompleteFileOps

const struct CompleteOps CompleteFileOps
extern

Auto-Completion of Files.

Definition at line 153 of file complete.c.

◆ CompleteMailboxOps

const struct CompleteOps CompleteMailboxOps
extern

Auto-Completion of Files / Mailboxes.

Definition at line 160 of file complete.c.