NeoMutt  2024-04-25-89-g194907
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.
 

Enumerations

enum  ExpandoDataFolder {
  ED_FOL_DATE = 1 , ED_FOL_DATE_FORMAT , ED_FOL_DESCRIPTION , ED_FOL_FILENAME ,
  ED_FOL_FILE_GROUP , ED_FOL_FILE_MODE , ED_FOL_FILE_OWNER , ED_FOL_FILE_SIZE ,
  ED_FOL_FLAGS , ED_FOL_FLAGS2 , ED_FOL_HARD_LINKS , ED_FOL_MESSAGE_COUNT ,
  ED_FOL_NEWSGROUP , ED_FOL_NEW_COUNT , ED_FOL_NEW_MAIL , ED_FOL_NOTIFY ,
  ED_FOL_NUMBER , ED_FOL_POLL , ED_FOL_STRF , ED_FOL_TAGGED ,
  ED_FOL_UNREAD_COUNT
}
 Expando UIDs for the File Browser. More...
 

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.

Enumeration Type Documentation

◆ ExpandoDataFolder

Expando UIDs for the File Browser.

See also
ED_FOLDER, ExpandoDomain
Enumerator
ED_FOL_DATE 

FolderFile.mtime.

ED_FOL_DATE_FORMAT 

FolderFile.mtime.

ED_FOL_DESCRIPTION 

FolderFile.desc, FolderFile.name.

ED_FOL_FILENAME 

FolderFile.name.

ED_FOL_FILE_GROUP 

FolderFile.gid.

ED_FOL_FILE_MODE 

FolderFile.move.

ED_FOL_FILE_OWNER 

FolderFile.uid.

ED_FOL_FILE_SIZE 

FolderFile.size.

ED_FOL_FLAGS 

FolderFile.nd (NntpMboxData)

ED_FOL_FLAGS2 

FolderFile.nd (NntpMboxData)

ED_FOL_HARD_LINKS 

FolderFile.nlink.

ED_FOL_MESSAGE_COUNT 

FolderFile.msg_count.

ED_FOL_NEWSGROUP 

FolderFile.name.

ED_FOL_NEW_COUNT 

FolderFile.nd (NntpMboxData)

ED_FOL_NEW_MAIL 

FolderFile.has_new_mail.

ED_FOL_NOTIFY 

FolderFile.notify_user.

ED_FOL_NUMBER 

Folder.num.

ED_FOL_POLL 

FolderFile.poll_new_mail.

ED_FOL_STRF 

FolderFile.mtime.

ED_FOL_TAGGED 

FolderFile.tagged.

ED_FOL_UNREAD_COUNT 

FolderFile.msg_unread.

Definition at line 115 of file lib.h.

116{
117 ED_FOL_DATE = 1,
138};
@ ED_FOL_POLL
FolderFile.poll_new_mail.
Definition: lib.h:134
@ ED_FOL_NOTIFY
FolderFile.notify_user.
Definition: lib.h:132
@ ED_FOL_NEW_COUNT
FolderFile.nd (NntpMboxData)
Definition: lib.h:130
@ ED_FOL_FILE_OWNER
FolderFile.uid.
Definition: lib.h:123
@ ED_FOL_FILE_GROUP
FolderFile.gid.
Definition: lib.h:121
@ ED_FOL_FILENAME
FolderFile.name.
Definition: lib.h:120
@ ED_FOL_DATE_FORMAT
FolderFile.mtime.
Definition: lib.h:118
@ ED_FOL_UNREAD_COUNT
FolderFile.msg_unread.
Definition: lib.h:137
@ ED_FOL_FLAGS2
FolderFile.nd (NntpMboxData)
Definition: lib.h:126
@ ED_FOL_FILE_MODE
FolderFile.move.
Definition: lib.h:122
@ ED_FOL_NEW_MAIL
FolderFile.has_new_mail.
Definition: lib.h:131
@ ED_FOL_FILE_SIZE
FolderFile.size.
Definition: lib.h:124
@ ED_FOL_HARD_LINKS
FolderFile.nlink.
Definition: lib.h:127
@ ED_FOL_DATE
FolderFile.mtime.
Definition: lib.h:117
@ ED_FOL_STRF
FolderFile.mtime.
Definition: lib.h:135
@ ED_FOL_TAGGED
FolderFile.tagged.
Definition: lib.h:136
@ ED_FOL_NUMBER
Folder.num.
Definition: lib.h:133
@ ED_FOL_DESCRIPTION
FolderFile.desc, FolderFile.name.
Definition: lib.h:119
@ ED_FOL_MESSAGE_COUNT
FolderFile.msg_count.
Definition: lib.h:128
@ ED_FOL_NEWSGROUP
FolderFile.name.
Definition: lib.h:129
@ ED_FOL_FLAGS
FolderFile.nd (NntpMboxData)
Definition: lib.h:125

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 1272 of file dlg_browser.c.

1273{
1274 init_lastdir();
1275
1277
1278 /* Method that will fetch the parent path depending on the type of the path. */
1279 char buf[PATH_MAX] = { 0 };
1280 mutt_get_parent_path(buf_string(&LastDirBackup), buf, sizeof(buf));
1281 buf_strcpy(&LastDir, buf);
1282}
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
static void init_lastdir(void)
Initialise the browser directories.
Definition: dlg_browser.c:148
struct Buffer LastDir
Browser: previous selected directory.
Definition: dlg_browser.c:139
struct Buffer LastDirBackup
Browser: backup copy of the current directory.
Definition: dlg_browser.c:141
#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:936
+ 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 162 of file dlg_browser.c.

163{
166}
void buf_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:377
+ 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:47
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
Definition: helpers.c:266
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:145
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:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ 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 637 of file dlg_browser.c.

640{
641 if ((!menu || state->is_mailbox_list) && m && !m->visible)
642 {
643 return;
644 }
645
646 struct FolderFile ff = { 0 };
647
648 if (st)
649 {
650 ff.mode = st->st_mode;
651 ff.mtime = st->st_mtime;
652 ff.size = st->st_size;
653 ff.gid = st->st_gid;
654 ff.uid = st->st_uid;
655 ff.nlink = st->st_nlink;
656 ff.local = true;
657 }
658 else
659 {
660 ff.local = false;
661 }
662
663 if (m)
664 {
665 ff.has_mailbox = true;
666 ff.gen = m->gen;
667 ff.has_new_mail = m->has_new;
668 ff.msg_count = m->msg_count;
669 ff.msg_unread = m->msg_unread;
670 ff.notify_user = m->notify_user;
672 }
673
674 ff.name = mutt_str_dup(name);
675 ff.desc = mutt_str_dup(desc ? desc : name);
676 ff.imap = false;
677 if (OptNews)
678 ff.nd = data;
679
680 ARRAY_ADD(&state->entry, ff);
681}
#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:148
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 1002 of file dlg_browser.c.

1003{
1004 menu->top = 0;
1005 /* Reset menu position to 1.
1006 * We do not risk overflow as the init_menu function changes
1007 * current if it is bigger than state->entrylen. */
1008 if (!ARRAY_EMPTY(&state->entry) &&
1009 (mutt_str_equal(ARRAY_FIRST(&state->entry)->desc, "..") ||
1010 mutt_str_equal(ARRAY_FIRST(&state->entry)->desc, "../")))
1011 {
1012 /* Skip the first entry, unless there's only one entry. */
1013 menu_set_index(menu, (menu->max > 1));
1014 }
1015 else
1016 {
1017 menu_set_index(menu, 0);
1018 }
1019}
#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:174
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
int top
Entry that is the top of the current page.
Definition: lib.h:90
int max
Number of entries in the menu.
Definition: lib.h:81
+ 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 711 of file dlg_browser.c.

713{
714 int rc = -1;
715 struct Buffer *buf = buf_pool_get();
716 if (OptNews)
717 {
719
720 init_state(state, menu);
721
722 const struct Regex *c_mask = cs_subset_regex(NeoMutt->sub, "mask");
723 for (unsigned int i = 0; i < adata->groups_num; i++)
724 {
725 struct NntpMboxData *mdata = adata->groups_list[i];
726 if (!mdata)
727 continue;
728 if (prefix && *prefix && !mutt_str_startswith(mdata->group, prefix))
729 continue;
730 if (!mutt_regex_match(c_mask, mdata->group))
731 {
732 continue;
733 }
734 browser_add_folder(menu, state, mdata->group, NULL, NULL, NULL, mdata);
735 }
736 }
737 else
738 {
739 struct stat st = { 0 };
740 DIR *dir = NULL;
741 struct dirent *de = NULL;
742
743 while (stat(dirname, &st) == -1)
744 {
745 if (errno == ENOENT)
746 {
747 /* The last used directory is deleted, try to use the parent dir. */
748 char *c = strrchr(dirname, '/');
749
750 if (c && (c > dirname))
751 {
752 *c = '\0';
753 continue;
754 }
755 }
756 mutt_perror("%s", dirname);
757 goto ed_out;
758 }
759
760 if (!S_ISDIR(st.st_mode))
761 {
762 mutt_error(_("%s is not a directory"), dirname);
763 goto ed_out;
764 }
765
766 if (m)
768
769 dir = mutt_file_opendir(dirname, MUTT_OPENDIR_NONE);
770 if (!dir)
771 {
772 mutt_perror("%s", dirname);
773 goto ed_out;
774 }
775
776 init_state(state, menu);
777
778 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
780
781 const struct Regex *c_mask = cs_subset_regex(NeoMutt->sub, "mask");
782 while ((de = readdir(dir)))
783 {
784 if (mutt_str_equal(de->d_name, "."))
785 continue; /* we don't need . */
786
787 if (prefix && *prefix && !mutt_str_startswith(de->d_name, prefix))
788 {
789 continue;
790 }
791 if (!mutt_regex_match(c_mask, de->d_name))
792 {
793 continue;
794 }
795
796 buf_concat_path(buf, dirname, de->d_name);
797 if (lstat(buf_string(buf), &st) == -1)
798 continue;
799
800 /* No size for directories or symlinks */
801 if (S_ISDIR(st.st_mode) || S_ISLNK(st.st_mode))
802 st.st_size = 0;
803 else if (!S_ISREG(st.st_mode))
804 continue;
805
806 struct MailboxNode *np = NULL;
807 STAILQ_FOREACH(np, &ml, entries)
808 {
810 break;
811 }
812
813 if (np && m && m->poll_new_mail && mutt_str_equal(np->mailbox->realpath, m->realpath))
814 {
815 np->mailbox->msg_count = m->msg_count;
816 np->mailbox->msg_unread = m->msg_unread;
817 }
818 browser_add_folder(menu, state, de->d_name, NULL, &st, np ? np->mailbox : NULL, NULL);
819 }
821 closedir(dir);
822 }
823 browser_sort(state);
824 rc = 0;
825ed_out:
826 buf_pool_release(&buf);
827 return rc;
828}
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:509
const struct Regex * cs_subset_regex(const struct ConfigSubset *sub, const char *name)
Get a regex config item by name.
Definition: helpers.c:217
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
@ 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:688
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:637
DIR * mutt_file_opendir(const char *path, enum MuttOpenDirMode mode)
Open a directory.
Definition: file.c:642
@ 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:614
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:169
#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:168
size_t neomutt_mailboxlist_get_all(struct MailboxList *head, struct NeoMutt *n, enum MailboxType type)
Get a List of all Mailboxes.
Definition: neomutt.c:191
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:166
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:167
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 838 of file dlg_browser.c.

839{
840 struct stat st = { 0 };
841 struct Buffer *md = NULL;
842 struct Buffer *mailbox = NULL;
843
844 if (OptNews)
845 {
847
848 init_state(state, menu);
849
850 const bool c_show_only_unread = cs_subset_bool(NeoMutt->sub, "show_only_unread");
851 for (unsigned int i = 0; i < adata->groups_num; i++)
852 {
853 struct NntpMboxData *mdata = adata->groups_list[i];
854 if (mdata && (mdata->has_new_mail ||
855 (mdata->subscribed && (mdata->unread || !c_show_only_unread))))
856 {
857 browser_add_folder(menu, state, mdata->group, NULL, NULL, NULL, mdata);
858 }
859 }
860 }
861 else
862 {
863 init_state(state, menu);
864
866 return -1;
867 mailbox = buf_pool_get();
868 md = buf_pool_get();
869
871
872 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
874 struct MailboxNode *np = NULL;
875 const bool c_browser_abbreviate_mailboxes = cs_subset_bool(NeoMutt->sub, "browser_abbreviate_mailboxes");
876
877 STAILQ_FOREACH(np, &ml, entries)
878 {
879 if (!np->mailbox)
880 continue;
881
882 if (m && m->poll_new_mail && mutt_str_equal(np->mailbox->realpath, m->realpath))
883 {
884 np->mailbox->msg_count = m->msg_count;
885 np->mailbox->msg_unread = m->msg_unread;
886 }
887
889 if (c_browser_abbreviate_mailboxes)
891
892 switch (np->mailbox->type)
893 {
894 case MUTT_IMAP:
895 case MUTT_POP:
897 np->mailbox->name, NULL, np->mailbox, NULL);
898 continue;
899 case MUTT_NOTMUCH:
900 case MUTT_NNTP:
901 browser_add_folder(menu, state, mailbox_path(np->mailbox),
902 np->mailbox->name, NULL, np->mailbox, NULL);
903 continue;
904 default: /* Continue */
905 break;
906 }
907
908 if (lstat(mailbox_path(np->mailbox), &st) == -1)
909 continue;
910
911 if ((!S_ISREG(st.st_mode)) && (!S_ISDIR(st.st_mode)) && (!S_ISLNK(st.st_mode)))
912 continue;
913
914 if (np->mailbox->type == MUTT_MAILDIR)
915 {
916 struct stat st2 = { 0 };
917
918 buf_printf(md, "%s/new", mailbox_path(np->mailbox));
919 if (stat(buf_string(md), &st) < 0)
920 st.st_mtime = 0;
921 buf_printf(md, "%s/cur", mailbox_path(np->mailbox));
922 if (stat(buf_string(md), &st2) < 0)
923 st2.st_mtime = 0;
924 if (st2.st_mtime > st.st_mtime)
925 st.st_mtime = st2.st_mtime;
926 }
927
928 browser_add_folder(menu, state, buf_string(mailbox), np->mailbox->name,
929 &st, np->mailbox, NULL);
930 }
932 }
933 browser_sort(state);
934
935 buf_pool_release(&mailbox);
936 buf_pool_release(&md);
937 return 0;
938}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
@ 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:519
#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:47
+ 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 1028 of file dlg_browser.c.

1030{
1031 char title[256] = { 0 };
1032 menu->max = ARRAY_SIZE(&state->entry);
1033
1034 int index = menu_get_index(menu);
1035 if (index >= menu->max)
1036 menu_set_index(menu, menu->max - 1);
1037 if (index < 0)
1038 menu_set_index(menu, 0);
1039 if (menu->top > index)
1040 menu->top = 0;
1041
1042 menu->num_tagged = 0;
1043
1044 if (OptNews)
1045 {
1046 if (state->is_mailbox_list)
1047 {
1048 snprintf(title, sizeof(title), _("Subscribed newsgroups"));
1049 }
1050 else
1051 {
1052 snprintf(title, sizeof(title), _("Newsgroups on server [%s]"),
1054 }
1055 }
1056 else
1057 {
1058 if (state->is_mailbox_list)
1059 {
1060 snprintf(title, sizeof(title), _("Mailboxes [%d]"),
1062 }
1063 else
1064 {
1065 struct Buffer *path = buf_pool_get();
1066 buf_copy(path, &LastDir);
1067 buf_pretty_mailbox(path);
1068 const struct Regex *c_mask = cs_subset_regex(NeoMutt->sub, "mask");
1069 const bool c_imap_list_subscribed = cs_subset_bool(NeoMutt->sub, "imap_list_subscribed");
1070 if (state->imap_browse && c_imap_list_subscribed)
1071 {
1072 snprintf(title, sizeof(title), _("Subscribed [%s], File mask: %s"),
1073 buf_string(path), NONULL(c_mask ? c_mask->pattern : NULL));
1074 }
1075 else
1076 {
1077 snprintf(title, sizeof(title), _("Directory [%s], File mask: %s"),
1078 buf_string(path), NONULL(c_mask ? c_mask->pattern : NULL));
1079 }
1080 buf_pool_release(&path);
1081 }
1082 }
1083 sbar_set_title(sbar, title);
1084
1085 /* Browser tracking feature.
1086 * The goal is to highlight the good directory if LastDir is the parent dir
1087 * of LastDirBackup (this occurs mostly when one hit "../"). It should also work
1088 * properly when the user is in examine_mailboxes-mode. */
1090 {
1091 char target_dir[PATH_MAX] = { 0 };
1092
1093 /* Check what kind of dir LastDirBackup is. */
1095 {
1096 mutt_str_copy(target_dir, buf_string(&LastDirBackup), sizeof(target_dir));
1097 imap_clean_path(target_dir, sizeof(target_dir));
1098 }
1099 else
1100 {
1101 mutt_str_copy(target_dir, strrchr(buf_string(&LastDirBackup), '/') + 1,
1102 sizeof(target_dir));
1103 }
1104
1105 /* If we get here, it means that LastDir is the parent directory of
1106 * LastDirBackup. I.e., we're returning from a subdirectory, and we want
1107 * to position the cursor on the directory we're returning from. */
1108 bool matched = false;
1109 struct FolderFile *ff = NULL;
1110 ARRAY_FOREACH(ff, &state->entry)
1111 {
1112 if (mutt_str_equal(ff->name, target_dir))
1113 {
1114 menu_set_index(menu, ARRAY_FOREACH_IDX);
1115 matched = true;
1116 break;
1117 }
1118 }
1119 if (!matched)
1120 browser_highlight_default(state, menu);
1121 }
1122 else
1123 {
1124 browser_highlight_default(state, menu);
1125 }
1126
1128}
#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:601
void browser_highlight_default(struct BrowserState *state, struct Menu *menu)
Decide which browser item should be highlighted.
Definition: dlg_browser.c:1002
enum MailboxType imap_path_probe(const char *path, const struct stat *st)
Is this an IMAP Mailbox? - Implements MxOps::path_probe() -.
Definition: imap.c:2345
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:184
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:160
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:581
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:146
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:93
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 688 of file dlg_browser.c.

689{
690 ARRAY_INIT(&state->entry);
691 ARRAY_RESERVE(&state->entry, 256);
692 state->imap_browse = false;
693
694 if (menu)
695 {
696 menu->mdata = &state->entry;
697 menu->mdata_free = NULL; // Menu doesn't own the data
698 }
699}
#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:161
void * mdata
Private data.
Definition: lib.h:147
+ 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 175 of file dlg_browser.c.

176{
177 struct stat st = { 0 };
178 bool rc = false;
179
180 struct Buffer *fullpath = buf_pool_get();
181 buf_concat_path(fullpath, folder, path);
182
183 if (stat(buf_string(fullpath), &st) == 0)
184 rc = S_ISDIR(st.st_mode);
185
186 buf_pool_release(&fullpath);
187
188 return rc;
189}
+ 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:147
+ 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 139 of file dlg_browser.c.

◆ LastDirBackup

struct Buffer LastDirBackup
extern

Browser: backup copy of the current directory.

Definition at line 141 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.