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 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_DATE_STRF , 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_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)
	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

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

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

enum 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_DATE_STRF	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_TAGGED	FolderFile.tagged.
ED_FOL_UNREAD_COUNT	FolderFile.msg_unread.

Definition at line 115 of file lib.h.

{
  ED_FOL_DATE = 1,             
  ED_FOL_DATE_FORMAT,          
  ED_FOL_DATE_STRF,            
  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_TAGGED,               
  ED_FOL_UNREAD_COUNT,         
};

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

f	Directory 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 829 of file dlg_browser.c.

{
  init_lastdir();
 
  buf_strcpy(&LastDirBackup, f);
 
  /* Method that will fetch the parent path depending on the type of the path. */
  char buf[PATH_MAX] = { 0 };
  mutt_get_parent_path(buf_string(&LastDirBackup), buf, sizeof(buf));
  buf_strcpy(&LastDir, buf);
}

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

{
  buf_dealloc(&LastDir);
  buf_dealloc(&LastDirBackup);
}

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

state

Browser 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.

{
  const enum EmailSortType c_browser_sort = cs_subset_sort(NeoMutt->sub, "browser_sort");
  switch (c_browser_sort & SORT_MASK)
  {
    case BROWSER_SORT_SIZE:
    case BROWSER_SORT_DATE:
      if (OptNews)
        return;
      FALLTHROUGH;
    default:
      break;
  }
 
  sort_t f = NULL;
  switch (c_browser_sort & SORT_MASK)
  {
    case BROWSER_SORT_COUNT:
      f = browser_sort_count;
      break;
    case BROWSER_SORT_DATE:
      f = browser_sort_date;
      break;
    case BROWSER_SORT_DESC:
      f = browser_sort_desc;
      break;
    case BROWSER_SORT_SIZE:
      f = browser_sort_size;
      break;
    case BROWSER_SORT_NEW:
      f = browser_sort_new;
      break;
    case BROWSER_SORT_ALPHA:
      f = browser_sort_subject;
      break;
    case BROWSER_SORT_UNSORTED:
    default:
      f = browser_sort_unsorted;
      break;
  }
 
  struct CompareData cd = {
    .sort_fn = f,
    .sort_reverse = c_browser_sort & SORT_REVERSE,
    .sort_dirs_first = cs_subset_bool(NeoMutt->sub, "browser_sort_dirs_first"),
  };
 
  ARRAY_SORT(&state->entry, browser_sort_helper, &cd);
}

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

menu	Menu to use
state	Browser state
name	Name of folder
desc	Description of folder
st	stat info for the folder
m	Mailbox
data	Data to associate with the folder

Definition at line 197 of file dlg_browser.c.

{
  if ((!menu || state->is_mailbox_list) && m && !m->visible)
  {
    return;
  }
 
  struct FolderFile ff = { 0 };
 
  if (st)
  {
    ff.mode = st->st_mode;
    ff.mtime = st->st_mtime;
    ff.size = st->st_size;
    ff.gid = st->st_gid;
    ff.uid = st->st_uid;
    ff.nlink = st->st_nlink;
    ff.local = true;
  }
  else
  {
    ff.local = false;
  }
 
  if (m)
  {
    ff.has_mailbox = true;
    ff.gen = m->gen;
    ff.has_new_mail = m->has_new;
    ff.msg_count = m->msg_count;
    ff.msg_unread = m->msg_unread;
    ff.notify_user = m->notify_user;
    ff.poll_new_mail = m->poll_new_mail;
  }
 
  ff.name = mutt_str_dup(name);
  ff.desc = mutt_str_dup(desc ? desc : name);
  ff.imap = false;
  if (OptNews)
    ff.nd = data;
 
  ARRAY_ADD(&state->entry, ff);
}

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

state	Browser state
menu	Current Menu

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

Definition at line 558 of file dlg_browser.c.

{
  menu->top = 0;
  /* Reset menu position to 1.
   * We do not risk overflow as the init_menu function changes
   * current if it is bigger than state->entrylen.  */
  if (!ARRAY_EMPTY(&state->entry) &&
      (mutt_str_equal(ARRAY_FIRST(&state->entry)->desc, "..") ||
       mutt_str_equal(ARRAY_FIRST(&state->entry)->desc, "../")))
  {
    /* Skip the first entry, unless there's only one entry. */
    menu_set_index(menu, (menu->max > 1));
  }
  else
  {
    menu_set_index(menu, 0);
  }
}

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

m	Mailbox
menu	Current Menu
state	State of browser
dirname	Directory
prefix	Files/newsgroups must match this prefix

Return values

0	Success
-1	Error

Definition at line 264 of file dlg_browser.c.

{
  int rc = -1;
  struct Buffer *buf = buf_pool_get();
  if (OptNews)
  {
    struct NntpAccountData *adata = CurrentNewsSrv;
 
    init_state(state);
 
    const struct Regex *c_mask = cs_subset_regex(NeoMutt->sub, "mask");
    for (unsigned int i = 0; i < adata->groups_num; i++)
    {
      struct NntpMboxData *mdata = adata->groups_list[i];
      if (!mdata)
        continue;
      if (prefix && *prefix && !mutt_str_startswith(mdata->group, prefix))
        continue;
      if (!mutt_regex_match(c_mask, mdata->group))
      {
        continue;
      }
      browser_add_folder(menu, state, mdata->group, NULL, NULL, NULL, mdata);
    }
  }
  else
  {
    struct stat st = { 0 };
    DIR *dir = NULL;
    struct dirent *de = NULL;
 
    while (stat(dirname, &st) == -1)
    {
      if (errno == ENOENT)
      {
        /* The last used directory is deleted, try to use the parent dir. */
        char *c = strrchr(dirname, '/');
 
        if (c && (c > dirname))
        {
          *c = '\0';
          continue;
        }
      }
      mutt_perror("%s", dirname);
      goto ed_out;
    }
 
    if (!S_ISDIR(st.st_mode))
    {
      mutt_error(_("%s is not a directory"), dirname);
      goto ed_out;
    }
 
    if (m)
      mutt_mailbox_check(m, MUTT_MAILBOX_CHECK_NO_FLAGS);
 
    dir = mutt_file_opendir(dirname, MUTT_OPENDIR_NONE);
    if (!dir)
    {
      mutt_perror("%s", dirname);
      goto ed_out;
    }
 
    init_state(state);
 
    struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
    neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
 
    const struct Regex *c_mask = cs_subset_regex(NeoMutt->sub, "mask");
    while ((de = readdir(dir)))
    {
      if (mutt_str_equal(de->d_name, "."))
        continue; /* we don't need . */
 
      if (prefix && *prefix && !mutt_str_startswith(de->d_name, prefix))
      {
        continue;
      }
      if (!mutt_regex_match(c_mask, de->d_name))
      {
        continue;
      }
 
      buf_concat_path(buf, dirname, de->d_name);
      if (lstat(buf_string(buf), &st) == -1)
        continue;
 
      /* No size for directories or symlinks */
      if (S_ISDIR(st.st_mode) || S_ISLNK(st.st_mode))
        st.st_size = 0;
      else if (!S_ISREG(st.st_mode))
        continue;
 
      struct MailboxNode *np = NULL;
      STAILQ_FOREACH(np, &ml, entries)
      {
        if (mutt_str_equal(buf_string(buf), mailbox_path(np->mailbox)))
          break;
      }
 
      if (np && m && m->poll_new_mail && mutt_str_equal(np->mailbox->realpath, m->realpath))
      {
        np->mailbox->msg_count = m->msg_count;
        np->mailbox->msg_unread = m->msg_unread;
      }
      browser_add_folder(menu, state, de->d_name, NULL, &st, np ? np->mailbox : NULL, NULL);
    }
    neomutt_mailboxlist_clear(&ml);
    closedir(dir);
  }
  browser_sort(state);
  rc = 0;
ed_out:
  buf_pool_release(&buf);
  return rc;
}

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

m	Mailbox
menu	Current menu
state	State of browser

Return values

0	Success
-1	Error

Definition at line 391 of file dlg_browser.c.

{
  struct stat st = { 0 };
  struct Buffer *md = NULL;
  struct Buffer *mailbox = NULL;
 
  if (OptNews)
  {
    struct NntpAccountData *adata = CurrentNewsSrv;
 
    init_state(state);
 
    const bool c_show_only_unread = cs_subset_bool(NeoMutt->sub, "show_only_unread");
    for (unsigned int i = 0; i < adata->groups_num; i++)
    {
      struct NntpMboxData *mdata = adata->groups_list[i];
      if (mdata && (mdata->has_new_mail ||
                    (mdata->subscribed && (mdata->unread || !c_show_only_unread))))
      {
        browser_add_folder(menu, state, mdata->group, NULL, NULL, NULL, mdata);
      }
    }
  }
  else
  {
    init_state(state);
 
    if (TAILQ_EMPTY(&NeoMutt->accounts))
      return -1;
    mailbox = buf_pool_get();
    md = buf_pool_get();
 
    mutt_mailbox_check(m, MUTT_MAILBOX_CHECK_NO_FLAGS);
 
    struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
    neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
    struct MailboxNode *np = NULL;
    const bool c_browser_abbreviate_mailboxes = cs_subset_bool(NeoMutt->sub, "browser_abbreviate_mailboxes");
 
    STAILQ_FOREACH(np, &ml, entries)
    {
      if (!np->mailbox)
        continue;
 
      if (m && m->poll_new_mail && mutt_str_equal(np->mailbox->realpath, m->realpath))
      {
        np->mailbox->msg_count = m->msg_count;
        np->mailbox->msg_unread = m->msg_unread;
      }
 
      buf_strcpy(mailbox, mailbox_path(np->mailbox));
      if (c_browser_abbreviate_mailboxes)
        buf_pretty_mailbox(mailbox);
 
      switch (np->mailbox->type)
      {
        case MUTT_IMAP:
        case MUTT_POP:
          browser_add_folder(menu, state, buf_string(mailbox),
                             np->mailbox->name, NULL, np->mailbox, NULL);
          continue;
        case MUTT_NOTMUCH:
        case MUTT_NNTP:
          browser_add_folder(menu, state, mailbox_path(np->mailbox),
                             np->mailbox->name, NULL, np->mailbox, NULL);
          continue;
        default: /* Continue */
          break;
      }
 
      if (lstat(mailbox_path(np->mailbox), &st) == -1)
        continue;
 
      if ((!S_ISREG(st.st_mode)) && (!S_ISDIR(st.st_mode)) && (!S_ISLNK(st.st_mode)))
        continue;
 
      if (np->mailbox->type == MUTT_MAILDIR)
      {
        struct stat st2 = { 0 };
 
        buf_printf(md, "%s/new", mailbox_path(np->mailbox));
        if (stat(buf_string(md), &st) < 0)
          st.st_mtime = 0;
        buf_printf(md, "%s/cur", mailbox_path(np->mailbox));
        if (stat(buf_string(md), &st2) < 0)
          st2.st_mtime = 0;
        if (st2.st_mtime > st.st_mtime)
          st.st_mtime = st2.st_mtime;
      }
 
      browser_add_folder(menu, state, buf_string(mailbox), np->mailbox->name,
                         &st, np->mailbox, NULL);
    }
    neomutt_mailboxlist_clear(&ml);
  }
  browser_sort(state);
 
  buf_pool_release(&mailbox);
  buf_pool_release(&md);
  return 0;
}

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

state	Browser state
menu	Current menu
m	Mailbox
sbar	Status bar

Definition at line 584 of file dlg_browser.c.

{
  char title[256] = { 0 };
  menu->max = ARRAY_SIZE(&state->entry);
 
  int index = menu_get_index(menu);
  if (index >= menu->max)
    menu_set_index(menu, menu->max - 1);
  if (index < 0)
    menu_set_index(menu, 0);
  if (menu->top > index)
    menu->top = 0;
 
  menu->num_tagged = 0;
 
  if (OptNews)
  {
    if (state->is_mailbox_list)
    {
      snprintf(title, sizeof(title), _("Subscribed newsgroups"));
    }
    else
    {
      snprintf(title, sizeof(title), _("Newsgroups on server [%s]"),
               CurrentNewsSrv->conn->account.host);
    }
  }
  else
  {
    if (state->is_mailbox_list)
    {
      snprintf(title, sizeof(title), _("Mailboxes [%d]"),
               mutt_mailbox_check(m, MUTT_MAILBOX_CHECK_NO_FLAGS));
    }
    else
    {
      struct Buffer *path = buf_pool_get();
      buf_copy(path, &LastDir);
      buf_pretty_mailbox(path);
      const struct Regex *c_mask = cs_subset_regex(NeoMutt->sub, "mask");
      const bool c_imap_list_subscribed = cs_subset_bool(NeoMutt->sub, "imap_list_subscribed");
      if (state->imap_browse && c_imap_list_subscribed)
      {
        snprintf(title, sizeof(title), _("Subscribed [%s], File mask: %s"),
                 buf_string(path), NONULL(c_mask ? c_mask->pattern : NULL));
      }
      else
      {
        snprintf(title, sizeof(title), _("Directory [%s], File mask: %s"),
                 buf_string(path), NONULL(c_mask ? c_mask->pattern : NULL));
      }
      buf_pool_release(&path);
    }
  }
  sbar_set_title(sbar, title);
 
  /* Browser tracking feature.
   * The goal is to highlight the good directory if LastDir is the parent dir
   * of LastDirBackup (this occurs mostly when one hit "../"). It should also work
   * properly when the user is in examine_mailboxes-mode.  */
  if (mutt_str_startswith(buf_string(&LastDirBackup), buf_string(&LastDir)))
  {
    char target_dir[PATH_MAX] = { 0 };
 
    /* Check what kind of dir LastDirBackup is. */
    if (imap_path_probe(buf_string(&LastDirBackup), NULL) == MUTT_IMAP)
    {
      mutt_str_copy(target_dir, buf_string(&LastDirBackup), sizeof(target_dir));
      imap_clean_path(target_dir, sizeof(target_dir));
    }
    else
    {
      mutt_str_copy(target_dir, strrchr(buf_string(&LastDirBackup), '/') + 1,
                    sizeof(target_dir));
    }
 
    /* If we get here, it means that LastDir is the parent directory of
     * LastDirBackup.  I.e., we're returning from a subdirectory, and we want
     * to position the cursor on the directory we're returning from. */
    bool matched = false;
    struct FolderFile *ff = NULL;
    ARRAY_FOREACH(ff, &state->entry)
    {
      if (mutt_str_equal(ff->name, target_dir))
      {
        menu_set_index(menu, ARRAY_FOREACH_IDX_ff);
        matched = true;
        break;
      }
    }
    if (!matched)
      browser_highlight_default(state, menu);
  }
  else
  {
    browser_highlight_default(state, menu);
  }
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_state()

void init_state

(

struct BrowserState *

state

)

Initialise a browser state.

Parameters

state

BrowserState to initialise

Definition at line 247 of file dlg_browser.c.

{
  ARRAY_INIT(&state->entry);
  ARRAY_RESERVE(&state->entry, 256);
  state->imap_browse = false;
}

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

folder	Folder
path	Link name

Return values

true	Links to a directory
false	Otherwise

Definition at line 171 of file dlg_browser.c.

{
  struct stat st = { 0 };
  bool rc = false;
 
  struct Buffer *fullpath = buf_pool_get();
  buf_concat_path(fullpath, folder, path);
 
  if (stat(buf_string(fullpath), &st) == 0)
    rc = S_ISDIR(st.st_mode);
 
  buf_pool_release(&fullpath);
 
  return rc;
}

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

state

State to free

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

Definition at line 135 of file functions.c.

{
  struct FolderFile *ff = NULL;
  ARRAY_FOREACH(ff, &state->entry)
  {
    FREE(&ff->name);
    FREE(&ff->desc);
  }
  ARRAY_FREE(&state->entry);
  FREE(&state->folder);
}

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

{ 0 };

LastDirBackup

struct Buffer LastDirBackup

extern

Browser: backup copy of the current directory.

Definition at line 137 of file dlg_browser.c.

{ 0 };

CompleteFileOps

const struct CompleteOps CompleteFileOps

extern

Auto-Completion of Files.

Definition at line 152 of file complete.c.

                                           {
  .complete = complete_file_simple,
};

CompleteMailboxOps

const struct CompleteOps CompleteMailboxOps

extern

Auto-Completion of Files / Mailboxes.

Definition at line 159 of file complete.c.

                                              {
  .complete = complete_file_mbox,
};