Browser Function API

Prototype for a Browser Function. More...

Functions
static int	op_browser_new_file (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Select a new file in this directory - Implements browser_function_t -.
static int	op_browser_subscribe (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Subscribe to current mbox (IMAP/NNTP only) - Implements browser_function_t -.
static int	op_browser_tell (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Display the currently selected file's name - Implements browser_function_t -.
static int	op_browser_toggle_lsub (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Toggle view all/subscribed mailboxes (IMAP only) - Implements browser_function_t -.
static int	op_browser_view_file (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	View file - Implements browser_function_t -.
static int	op_catchup (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Mark all articles in newsgroup as read - Implements browser_function_t -.
static int	op_change_directory (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Change directories - Implements browser_function_t -.
static int	op_create_mailbox (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Create a new mailbox (IMAP only) - Implements browser_function_t -.
static int	op_delete_mailbox (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Delete the current mailbox (IMAP only) - Implements browser_function_t -.
static int	op_browser_limit (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Limit the browser - Implements browser_function_t -.
static int	op_quit (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Save changes and exit this dialog - Implements browser_function_t -.
static int	op_jump (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Jump to an index number - Implements browser_function_t -.
static int	op_generic_select_entry (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Select the current entry - Implements browser_function_t -.
static int	op_load_active (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Load list of all newsgroups from NNTP server - Implements browser_function_t -.
static int	op_mailbox_list (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	List mailboxes with new mail - Implements browser_function_t -.
static int	op_rename_mailbox (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Rename the current mailbox (IMAP only) - Implements browser_function_t -.
static int	op_sort (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Sort messages - Implements browser_function_t -.
static int	op_subscribe_pattern (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Subscribe to newsgroups matching a pattern - Implements browser_function_t -.
static int	op_toggle_mailboxes (struct BrowserPrivateData *priv, const struct KeyEvent *event)
	Toggle whether to browse mailboxes or all files - Implements browser_function_t -.

Detailed Description

Prototype for a Browser Function.

Parameters

priv	Private Browser data
event	Event to process

Return values

enum	FunctionRetval

Precondition

priv is not NULL

event is not NULL

Function Documentation

op_browser_new_file()

int op_browser_new_file ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Select a new file in this directory - Implements browser_function_t -.

Definition at line 224 of file functions.c.

{
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  struct Buffer *buf = buf_pool_get();
  buf_printf(buf, "%s/", buf_string(&mod_data->last_dir));
 
  struct FileCompletionData cdata = { false, priv->mailbox, NULL, NULL, NULL };
  const int rc = mw_get_field(_("New file name: "), buf, MUTT_COMP_NONE,
                              HC_FILE, &CompleteMailboxOps, &cdata);
  if (rc != 0)
  {
    buf_pool_release(&buf);
    return FR_NO_ACTION;
  }
 
  buf_copy(priv->file, buf);
  buf_pool_release(&buf);
  priv->done = true;
  return FR_DONE;
}

Here is the call graph for this function:

op_browser_subscribe()

int op_browser_subscribe ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Subscribe to current mbox (IMAP/NNTP only) - Implements browser_function_t -.

This function handles:

• OP_BROWSER_SUBSCRIBE
• OP_BROWSER_UNSUBSCRIBE

Supports repeat-count: 5<subscribe> operates on the current entry and the next 4. Overruns are silently capped at the end of the list.

Definition at line 304 of file functions.c.

{
  struct NntpModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NNTP);
  const bool subscribe = (event->op == OP_BROWSER_SUBSCRIBE);
  const bool tagged = priv->menu->tag_prefix && (priv->menu->num_tagged > 0);
 
  if (ARRAY_EMPTY(&priv->state.entry))
  {
    mutt_error(OptNews ? _("No newsgroups match the browser limit") :
                         _("There are no mailboxes"));
    return FR_ERROR;
  }
 
  struct FolderFilePtrArray ffpa = ARRAY_HEAD_INITIALIZER;
  browser_add_selection(&ffpa, &priv->state, priv->menu, tagged, event->count);
  if (ARRAY_EMPTY(&ffpa))
  {
    ARRAY_FREE(&ffpa);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ffpa);
 
  if (OptNews)
  {
    struct NntpAccountData *adata = mod_data->current_news_srv;
    int rc = nntp_newsrc_parse(adata);
    if (rc < 0)
    {
      ARRAY_FREE(&ffpa);
      return FR_ERROR;
    }
 
    browser_apply_subscribe_nntp(&ffpa, adata, subscribe);
 
    if (!tagged)
    {
      const int index = menu_get_index(priv->menu);
      const int next = index + num;
      if (next < ARRAY_SIZE(&priv->state.entry))
        menu_set_index(priv->menu, next);
    }
 
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
    nntp_newsrc_update(adata);
    nntp_clear_cache(adata);
    nntp_newsrc_close(adata);
  }
  else
  {
    browser_apply_subscribe_imap(&ffpa, subscribe);
  }
 
  ARRAY_FREE(&ffpa);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_browser_tell()

int op_browser_tell ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Display the currently selected file's name - Implements browser_function_t -.

Definition at line 363 of file functions.c.

{
  int index = menu_get_index(priv->menu);
  if (ARRAY_EMPTY(&priv->state.entry))
    return FR_ERROR;
 
  struct FolderFile *ff = ARRAY_GET(&priv->state.entry, index);
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  struct Buffer *path = buf_pool_get();
  if (priv->state.is_mailbox_list)
  {
    buf_strcpy(path, ff->name);
    expand_path(path, false);
  }
  else if (ff->local)
  {
    buf_concat_path(path, buf_string(&mod_data->last_dir), ff->name);
  }
  else
  {
    buf_strcpy(path, ff->name);
  }
 
  if (!ff->local)
  {
    struct Url *url = url_parse(buf_string(path));
    if (url)
    {
      buf_reset(path);
      url_tobuffer(url, path, U_NONE);
      url_free(&url);
    }
  }
 
  mutt_message("%s", buf_string(path));
  buf_pool_release(&path);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_browser_toggle_lsub()

int op_browser_toggle_lsub ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Toggle view all/subscribed mailboxes (IMAP only) - Implements browser_function_t -.

Definition at line 405 of file functions.c.

{
  bool_str_toggle(NeoMutt->sub, "imap_list_subscribed", NULL);
 
  const bool c_imap_list_subscribed = cs_subset_bool(NeoMutt->sub, "imap_list_subscribed");
  mutt_message("set imap_list_subscribed = %s", c_imap_list_subscribed ? "yes" : "no");
 
  mutt_unget_op(OP_CHECK_NEW);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_browser_view_file()

int op_browser_view_file ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

View file - Implements browser_function_t -.

Definition at line 419 of file functions.c.

{
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  if (ARRAY_EMPTY(&priv->state.entry))
  {
    mutt_error(_("No files match the browser limit"));
    return FR_ERROR;
  }
 
  int index = menu_get_index(priv->menu);
  struct FolderFile *ff = ARRAY_GET(&priv->state.entry, index);
  if (ff->selectable)
  {
    buf_strcpy(priv->file, ff->name);
    priv->done = true;
    return FR_DONE;
  }
  else if (S_ISDIR(ff->mode) ||
           (S_ISLNK(ff->mode) && link_is_dir(buf_string(&mod_data->last_dir), ff->name)))
  {
    mutt_error(_("Can't view a directory"));
    return FR_ERROR;
  }
  else
  {
    struct Buffer *path = buf_pool_get();
    buf_concat_path(path, buf_string(&mod_data->last_dir), ff->name);
    struct Body *b = mutt_make_file_attach(buf_string(path), NeoMutt->sub);
    if (b)
    {
      mutt_view_attachment(NULL, b, MUTT_VA_REGULAR, NULL, NULL, priv->menu->win);
      mutt_body_free(&b);
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
    }
    else
    {
      mutt_error(_("Error trying to view file"));
    }
    buf_pool_release(&path);
  }
  return FR_ERROR;
}

Here is the call graph for this function:

op_catchup()

int op_catchup ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Mark all articles in newsgroup as read - Implements browser_function_t -.

This function handles:

• OP_CATCHUP
• OP_UNCATCHUP

Supports repeat-count: 5<catchup> operates on the current entry and the next 4. Overruns are silently capped at the end of the list.

Definition at line 502 of file functions.c.

{
  struct NntpModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NNTP);
  if (!OptNews)
    return FR_NOT_IMPL;
 
  int rc = nntp_newsrc_parse(mod_data->current_news_srv);
  if (rc < 0)
    return FR_ERROR;
 
  if (ARRAY_EMPTY(&priv->state.entry))
    return FR_ERROR;
 
  const bool tagged = priv->menu->tag_prefix && (priv->menu->num_tagged > 0);
 
  struct FolderFilePtrArray ffpa = ARRAY_HEAD_INITIALIZER;
  browser_add_selection(&ffpa, &priv->state, priv->menu, tagged, event->count);
  if (ARRAY_EMPTY(&ffpa))
  {
    ARRAY_FREE(&ffpa);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ffpa);
 
  struct NntpMboxData *mdata = browser_apply_catchup(&ffpa, priv->mailbox,
                                                     mod_data->current_news_srv,
                                                     (event->op == OP_CATCHUP));
  ARRAY_FREE(&ffpa);
 
  if (mdata)
  {
    nntp_newsrc_update(mod_data->current_news_srv);
    if (!tagged)
    {
      const int next = menu_get_index(priv->menu) + num;
      if (next < priv->menu->max)
        menu_set_index(priv->menu, next);
    }
  }
 
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
 
  nntp_newsrc_close(mod_data->current_news_srv);
  return FR_ERROR;
}

Here is the call graph for this function:

op_change_directory()

int op_change_directory ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Change directories - Implements browser_function_t -.

This function handles:

• OP_CHANGE_DIRECTORY
• OP_GOTO_HOME
• OP_GOTO_PARENT
• OP_GOTO_ROOT

Definition at line 557 of file functions.c.

{
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  if (OptNews)
    return FR_NOT_IMPL;
 
  struct Buffer *buf = buf_pool_get();
  buf_copy(buf, &mod_data->last_dir);
  if (!priv->state.imap_browse)
  {
    /* add '/' at the end of the directory name if not already there */
    size_t len = buf_len(buf);
    if ((len > 0) && (buf_string(&mod_data->last_dir)[len - 1] != '/'))
      buf_addch(buf, '/');
  }
 
  const int op = event->op;
  if (op == OP_CHANGE_DIRECTORY)
  {
    struct FileCompletionData cdata = { false, priv->mailbox, NULL, NULL, NULL };
    int rc = mw_get_field(_("Chdir to: "), buf, MUTT_COMP_NONE, HC_FILE,
                          &CompleteMailboxOps, &cdata);
    if ((rc != 0) && buf_is_empty(buf))
    {
      buf_pool_release(&buf);
      return FR_NO_ACTION;
    }
  }
  else if (op == OP_GOTO_PARENT)
  {
    const int count = MAX(event->count, 1);
    for (int i = 0; i < count; i++)
    {
      char prev[PATH_MAX] = { 0 };
      mutt_str_copy(prev, buf_string(buf), sizeof(prev));
      mutt_get_parent_path(buf_string(buf), buf->data, buf->dsize);
      if (mutt_str_equal(buf_string(buf), prev))
        break;
    }
  }
  else if (op == OP_GOTO_HOME)
  {
    buf_strcpy(buf, NeoMutt->home_dir);
  }
  else if (op == OP_GOTO_ROOT)
  {
    buf_strcpy(buf, "/");
  }
 
  if (!buf_is_empty(buf))
  {
    priv->state.is_mailbox_list = false;
    expand_path(buf, false);
    if (imap_path_probe(buf_string(buf), NULL) == MUTT_IMAP)
    {
      buf_copy(&mod_data->last_dir, buf);
      destroy_state(&priv->state);
      init_state(&priv->state);
      priv->state.imap_browse = true;
      imap_browse(buf_string(&mod_data->last_dir), &priv->state);
      browser_sort(&priv->state);
      browser_highlight_default(&priv->state, priv->menu);
      init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
    }
    else
    {
      if (buf_string(buf)[0] != '/')
      {
        /* in case dir is relative, make it relative to LastDir,
         * not current working dir */
        struct Buffer *tmp = buf_pool_get();
        buf_concat_path(tmp, buf_string(&mod_data->last_dir), buf_string(buf));
        buf_copy(buf, tmp);
        buf_pool_release(&tmp);
      }
      /* Resolve path from <chdir>
       * Avoids buildup such as /a/b/../../c
       * Symlinks are always unraveled to keep code simple */
      if (mutt_path_realpath(buf) == 0)
      {
        mutt_perror("%s", buf_string(buf));
        buf_pool_release(&buf);
        return FR_ERROR;
      }
 
      struct stat st = { 0 };
      if (stat(buf_string(buf), &st) == 0)
      {
        if (S_ISDIR(st.st_mode))
        {
          destroy_state(&priv->state);
          if (examine_directory(priv->mailbox, priv->menu, &priv->state,
                                buf_string(buf), buf_string(priv->prefix)) == 0)
          {
            buf_copy(&mod_data->last_dir, buf);
          }
          else
          {
            mutt_error(_("Error scanning directory"));
            if (examine_directory(priv->mailbox, priv->menu, &priv->state,
                                  buf_string(&mod_data->last_dir),
                                  buf_string(priv->prefix)) == -1)
            {
              priv->done = true;
              return FR_ERROR;
            }
          }
          browser_highlight_default(&priv->state, priv->menu);
          init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
        }
        else
        {
          mutt_error(_("%s is not a directory"), buf_string(buf));
        }
      }
      else
      {
        mutt_perror("%s", buf_string(buf));
      }
    }
  }
  buf_pool_release(&buf);
  return FR_ERROR;
}

Here is the call graph for this function:

op_create_mailbox()

int op_create_mailbox ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Create a new mailbox (IMAP only) - Implements browser_function_t -.

Definition at line 685 of file functions.c.

{
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  if (!priv->state.imap_browse)
  {
    mutt_error(_("Create is only supported for IMAP mailboxes"));
    return FR_ERROR;
  }
 
  if (imap_mailbox_create(buf_string(&mod_data->last_dir)) != 0)
    return FR_ERROR;
 
  /* TODO: find a way to detect if the new folder would appear in
   *   this window, and insert it without starting over. */
  destroy_state(&priv->state);
  init_state(&priv->state);
  priv->state.imap_browse = true;
  imap_browse(buf_string(&mod_data->last_dir), &priv->state);
  browser_sort(&priv->state);
  browser_highlight_default(&priv->state, priv->menu);
  init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_delete_mailbox()

int op_delete_mailbox ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Delete the current mailbox (IMAP only) - Implements browser_function_t -.

Supports repeat-count: 5<delete-mailbox> deletes the current entry and the next 4. Overruns are silently capped at the end of the list.

Definition at line 759 of file functions.c.

{
  if (ARRAY_EMPTY(&priv->state.entry))
    return FR_ERROR;
 
  const bool tagged = priv->menu->tag_prefix && (priv->menu->num_tagged > 0);
 
  struct FolderFilePtrArray ffpa = ARRAY_HEAD_INITIALIZER;
  browser_add_selection(&ffpa, &priv->state, priv->menu, tagged, event->count);
  if (ARRAY_EMPTY(&ffpa))
  {
    ARRAY_FREE(&ffpa);
    return FR_NO_ACTION;
  }
 
  // Pre-flight validation
  struct FolderFile **ffp = NULL;
  ARRAY_FOREACH(ffp, &ffpa)
  {
    struct FolderFile *ff = *ffp;
    if (!ff->imap)
    {
      mutt_error(_("Delete is only supported for IMAP mailboxes"));
      ARRAY_FREE(&ffpa);
      return FR_ERROR;
    }
    // TODO(sileht): It could be better to select INBOX instead. But I
    // don't want to manipulate Mailboxes/mailbox->account here for now.
    // Let's just protect neomutt against crash for now. #1417
    if (mutt_str_equal(mailbox_path(priv->mailbox), ff->name))
    {
      mutt_error(_("Can't delete currently selected mailbox"));
      ARRAY_FREE(&ffpa);
      return FR_ERROR;
    }
  }
 
  const int num = ARRAY_SIZE(&ffpa);
  char msg[128] = { 0 };
  if (num > 1)
  {
    snprintf(msg, sizeof(msg), _("Really delete %d tagged mailboxes?"), num);
  }
  else
  {
    struct FolderFile *ff = *ARRAY_FIRST(&ffpa);
    snprintf(msg, sizeof(msg), _("Really delete mailbox \"%s\"?"), ff->name);
  }
  if (query_yesorno(msg, MUTT_NO) != MUTT_YES)
  {
    mutt_message(_("Mailbox not deleted"));
    ARRAY_FREE(&ffpa);
    return FR_NO_ACTION;
  }
 
  int failed = 0;
  const int deleted = browser_apply_delete_mailbox(&ffpa, &priv->state,
                                                   priv->mailbox, &failed);
  ARRAY_FREE(&ffpa);
 
  if (failed > 0)
    mutt_error(_("Mailbox deletion failed"));
  else if (num > 1)
    mutt_message(_("%d mailboxes deleted"), deleted);
  else if (deleted == 1)
    mutt_message(_("Mailbox deleted"));
 
  init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
  return failed ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_browser_limit()

int op_browser_limit ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Limit the browser - Implements browser_function_t -.

Definition at line 833 of file functions.c.

{
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  const struct Regex *c_browser_limit = cs_subset_regex(NeoMutt->sub, "browser_limit");
  struct Buffer *buf = buf_pool_get();
  buf_strcpy(buf, c_browser_limit ? c_browser_limit->pattern : NULL);
  if (mw_get_field(_("Limit: "), buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) != 0)
  {
    buf_pool_release(&buf);
    return FR_NO_ACTION;
  }
 
  buf_fix_dptr(buf);
 
  priv->state.is_mailbox_list = false;
  /* assume that the user wants to see everything */
  if (buf_is_empty(buf))
    buf_strcpy(buf, ".");
 
  struct Buffer *errmsg = buf_pool_get();
  int rc = cs_subset_str_string_set(NeoMutt->sub, "browser_limit", buf_string(buf), errmsg);
  buf_pool_release(&buf);
  if (CSR_RESULT(rc) != CSR_SUCCESS)
  {
    if (!buf_is_empty(errmsg))
    {
      mutt_error("%s", buf_string(errmsg));
      buf_pool_release(&errmsg);
    }
    return FR_ERROR;
  }
  buf_pool_release(&errmsg);
 
  destroy_state(&priv->state);
  if (priv->state.imap_browse)
  {
    init_state(&priv->state);
    priv->state.imap_browse = true;
    imap_browse(buf_string(&mod_data->last_dir), &priv->state);
    browser_sort(&priv->state);
    init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
  }
  else if (examine_directory(priv->mailbox, priv->menu, &priv->state,
                             buf_string(&mod_data->last_dir), NULL) == 0)
  {
    init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
  }
  else
  {
    mutt_error(_("Error scanning directory"));
    priv->done = true;
    return FR_ERROR;
  }
  priv->kill_prefix = false;
  if (ARRAY_EMPTY(&priv->state.entry))
  {
    mutt_error(_("No files match the browser limit"));
    return FR_ERROR;
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_quit()

int op_quit ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Save changes and exit this dialog - Implements browser_function_t -.

Definition at line 898 of file functions.c.

{
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  if (priv->multiple)
  {
    char **tfiles = NULL;
 
    if (priv->menu->tag_prefix && (priv->menu->num_tagged != 0))
    {
      *priv->numfiles = priv->menu->num_tagged;
      tfiles = MUTT_MEM_CALLOC(*priv->numfiles, char *);
      size_t j = 0;
      struct FolderFile *ff = NULL;
      ARRAY_FOREACH(ff, &priv->state.entry)
      {
        if (ff->tagged)
        {
          struct Buffer *buf = buf_pool_get();
          buf_concat_path(buf, buf_string(&mod_data->last_dir), ff->name);
          expand_path(buf, false);
          tfiles[j++] = buf_strdup(buf);
          buf_pool_release(&buf);
        }
      }
      *priv->files = tfiles;
    }
    else if (!buf_is_empty(priv->file)) /* no tagged entries. return selected entry */
    {
      *priv->numfiles = 1;
      tfiles = MUTT_MEM_CALLOC(*priv->numfiles, char *);
      expand_path(priv->file, false);
      tfiles[0] = buf_strdup(priv->file);
      *priv->files = tfiles;
    }
  }
 
  priv->done = true;
  return FR_DONE;
}

Here is the call graph for this function:

op_jump()

int op_jump ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Jump to an index number - Implements browser_function_t -.

Definition at line 941 of file functions.c.

{
  int num = event->count;
 
  if (num == 0)
    return FR_NO_ACTION;
 
  struct Menu *menu = priv->menu;
 
  if ((num < 1) || (num > menu->max))
  {
    mutt_warning(_("Invalid message number"));
    return FR_ERROR;
  }
 
  menu_set_index(menu, num - 1); // Num is 1-based
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_generic_select_entry()

int op_generic_select_entry ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Select the current entry - Implements browser_function_t -.

This function handles:

• OP_DESCEND_DIRECTORY
• OP_GENERIC_SELECT_ENTRY

Definition at line 967 of file functions.c.

{
  if (event->count > 0)
    return op_jump(priv, event);
 
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  if (ARRAY_EMPTY(&priv->state.entry))
  {
    mutt_warning(_("No files match the browser limit"));
    return FR_ERROR;
  }
 
  const int op = event->op;
  int index = menu_get_index(priv->menu);
  struct FolderFile *ff = ARRAY_GET(&priv->state.entry, index);
  if ((priv->menu->tag_prefix) && (op == OP_GENERIC_SELECT_ENTRY))
  {
    // Do nothing
  }
  else if (S_ISDIR(ff->mode) ||
           (S_ISLNK(ff->mode) && link_is_dir(buf_string(&mod_data->last_dir), ff->name)) ||
           ff->inferiors)
  {
    /* make sure this isn't a MH or maildir mailbox */
    struct Buffer *buf = buf_pool_get();
    if (priv->state.is_mailbox_list)
    {
      buf_strcpy(buf, ff->name);
      expand_path(buf, false);
    }
    else if (priv->state.imap_browse)
    {
      buf_strcpy(buf, ff->name);
    }
    else
    {
      buf_concat_path(buf, buf_string(&mod_data->last_dir), ff->name);
    }
 
    enum MailboxType type = mx_path_probe(buf_string(buf));
    buf_pool_release(&buf);
 
    if ((op == OP_DESCEND_DIRECTORY) || (type == MUTT_MAILBOX_ERROR) ||
        (type == MUTT_UNKNOWN) || ff->inferiors)
    {
      /* save the old directory */
      buf_copy(priv->old_last_dir, &mod_data->last_dir);
 
      if (mutt_str_equal(ff->name, ".."))
      {
        size_t lastdirlen = buf_len(&mod_data->last_dir);
        if ((lastdirlen > 1) &&
            mutt_str_equal("..", buf_string(&mod_data->last_dir) + lastdirlen - 2))
        {
          buf_addstr(&mod_data->last_dir, "/..");
        }
        else
        {
          char *p = NULL;
          if (lastdirlen > 1)
            p = strrchr(mod_data->last_dir.data + 1, '/');
 
          if (p)
          {
            *p = '\0';
            buf_fix_dptr(&mod_data->last_dir);
          }
          else
          {
            if (buf_string(&mod_data->last_dir)[0] == '/')
              buf_strcpy(&mod_data->last_dir, "/");
            else
              buf_addstr(&mod_data->last_dir, "/..");
          }
        }
      }
      else if (priv->state.is_mailbox_list)
      {
        buf_strcpy(&mod_data->last_dir, ff->name);
        expand_path(&mod_data->last_dir, false);
      }
      else if (priv->state.imap_browse)
      {
        buf_strcpy(&mod_data->last_dir, ff->name);
        /* tack on delimiter here */
 
        /* special case "" needs no delimiter */
        struct Url *url = url_parse(ff->name);
        if (url && url->path && (ff->delim != '\0'))
        {
          buf_addch(&mod_data->last_dir, ff->delim);
        }
        url_free(&url);
      }
      else
      {
        struct Buffer *tmp = buf_pool_get();
        buf_concat_path(tmp, buf_string(&mod_data->last_dir), ff->name);
        buf_copy(&mod_data->last_dir, tmp);
        buf_pool_release(&tmp);
      }
 
      destroy_state(&priv->state);
      if (priv->kill_prefix)
      {
        buf_reset(priv->prefix);
        priv->kill_prefix = false;
      }
      priv->state.is_mailbox_list = false;
      if (priv->state.imap_browse)
      {
        init_state(&priv->state);
        priv->state.imap_browse = true;
        imap_browse(buf_string(&mod_data->last_dir), &priv->state);
        browser_sort(&priv->state);
      }
      else
      {
        if (examine_directory(priv->mailbox, priv->menu, &priv->state,
                              buf_string(&mod_data->last_dir),
                              buf_string(priv->prefix)) == -1)
        {
          /* try to restore the old values */
          buf_copy(&mod_data->last_dir, priv->old_last_dir);
          if (examine_directory(priv->mailbox, priv->menu, &priv->state,
                                buf_string(&mod_data->last_dir),
                                buf_string(priv->prefix)) == -1)
          {
            buf_strcpy(&mod_data->last_dir, NeoMutt->home_dir);
            priv->done = true;
            return FR_DONE;
          }
        }
        /* resolve paths navigated from GUI */
        if (mutt_path_realpath(&mod_data->last_dir) == 0)
          return FR_ERROR;
      }
 
      browser_highlight_default(&priv->state, priv->menu);
      init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
      priv->goto_swapper[0] = '\0';
      return FR_SUCCESS;
    }
  }
  else if (op == OP_DESCEND_DIRECTORY)
  {
    mutt_error(_("%s is not a directory"), ARRAY_GET(&priv->state.entry, index)->name);
    return FR_ERROR;
  }
 
  if (priv->state.is_mailbox_list || OptNews)
  {
    buf_strcpy(priv->file, ff->name);
    expand_path(priv->file, false);
  }
  else if (priv->state.imap_browse)
  {
    buf_strcpy(priv->file, ff->name);
  }
  else
  {
    buf_concat_path(priv->file, buf_string(&mod_data->last_dir), ff->name);
  }
 
  return op_quit(priv, event);
}

Here is the call graph for this function:

op_load_active()

int op_load_active ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Load list of all newsgroups from NNTP server - Implements browser_function_t -.

Definition at line 1137 of file functions.c.

{
  struct NntpModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NNTP);
  if (!OptNews)
    return FR_NOT_IMPL;
 
  struct NntpAccountData *adata = mod_data->current_news_srv;
 
  if (nntp_newsrc_parse(adata) < 0)
    return FR_ERROR;
 
  for (size_t i = 0; i < adata->groups_num; i++)
  {
    struct NntpMboxData *mdata = adata->groups_list[i];
    if (mdata)
      mdata->deleted = true;
  }
  nntp_active_fetch(adata, true);
  nntp_newsrc_update(adata);
  nntp_newsrc_close(adata);
 
  destroy_state(&priv->state);
  if (priv->state.is_mailbox_list)
  {
    examine_mailboxes(priv->mailbox, priv->menu, &priv->state);
  }
  else
  {
    if (examine_directory(priv->mailbox, priv->menu, &priv->state, NULL, NULL) == -1)
      return FR_ERROR;
  }
  init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_mailbox_list()

int op_mailbox_list ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

List mailboxes with new mail - Implements browser_function_t -.

Definition at line 1175 of file functions.c.

{
  mutt_mailbox_list();
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_rename_mailbox()

int op_rename_mailbox ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Rename the current mailbox (IMAP only) - Implements browser_function_t -.

Definition at line 1184 of file functions.c.

{
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  if (ARRAY_EMPTY(&priv->state.entry))
    return FR_ERROR;
 
  int index = menu_get_index(priv->menu);
  struct FolderFile *ff = ARRAY_GET(&priv->state.entry, index);
  if (!ff->imap)
  {
    mutt_error(_("Rename is only supported for IMAP mailboxes"));
    return FR_ERROR;
  }
 
  if (imap_mailbox_rename(ff->name) < 0)
    return FR_ERROR;
 
  destroy_state(&priv->state);
  init_state(&priv->state);
  priv->state.imap_browse = true;
  imap_browse(buf_string(&mod_data->last_dir), &priv->state);
  browser_sort(&priv->state);
  browser_highlight_default(&priv->state, priv->menu);
  init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_sort()

int op_sort ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Sort messages - Implements browser_function_t -.

This function handles:

• OP_SORT
• OP_SORT_REVERSE

Definition at line 1219 of file functions.c.

{
  bool resort = true;
  int sort = -1;
  const int op = event->op;
  int reverse = (op == OP_SORT_REVERSE);
 
  switch (mw_multi_choice((reverse) ?
                              /* L10N: The highlighted letters must match the "Sort" options */
                              _("Reverse sort by (d)ate, (a)lpha, si(z)e, d(e)scription, (c)ount, ne(w) count, or do(n)'t sort?") :
                              /* L10N: The highlighted letters must match the "Reverse Sort" options */
                              _("Sort by (d)ate, (a)lpha, si(z)e, d(e)scription, (c)ount, ne(w) count, or do(n)'t sort?"),
                          /* L10N: These must match the highlighted letters from "Sort" and "Reverse Sort" */
                          _("dazecwn")))
  {
    case -1: /* abort */
      resort = false;
      break;
 
    case 1: /* (d)ate */
      sort = BROWSER_SORT_DATE;
      break;
 
    case 2: /* (a)lpha */
      sort = BROWSER_SORT_ALPHA;
      break;
 
    case 3: /* si(z)e */
      sort = BROWSER_SORT_SIZE;
      break;
 
    case 4: /* d(e)scription */
      sort = BROWSER_SORT_DESC;
      break;
 
    case 5: /* (c)ount */
      sort = BROWSER_SORT_COUNT;
      break;
 
    case 6: /* ne(w) count */
      sort = BROWSER_SORT_NEW;
      break;
 
    case 7: /* do(n)'t sort */
      sort = BROWSER_SORT_UNSORTED;
      break;
 
    default:
      resort = false;
      break;
  }
 
  if (!resort)
    return FR_NO_ACTION;
 
  sort |= reverse ? SORT_REVERSE : 0;
  cs_subset_str_native_set(NeoMutt->sub, "browser_sort", sort, NULL);
  browser_sort(&priv->state);
  browser_highlight_default(&priv->state, priv->menu);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_subscribe_pattern()

int op_subscribe_pattern ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Subscribe to newsgroups matching a pattern - Implements browser_function_t -.

This function handles:

• OP_SUBSCRIBE_PATTERN
• OP_UNSUBSCRIBE_PATTERN

Definition at line 1289 of file functions.c.

{
  struct NntpModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NNTP);
  if (!OptNews)
    return FR_NOT_IMPL;
 
  struct NntpAccountData *adata = mod_data->current_news_srv;
  regex_t rx = { 0 };
  int index = menu_get_index(priv->menu);
 
  char tmp2[256] = { 0 };
 
  const int op = event->op;
  struct Buffer *buf = buf_pool_get();
  if (op == OP_SUBSCRIBE_PATTERN)
    snprintf(tmp2, sizeof(tmp2), _("Subscribe pattern: "));
  else
    snprintf(tmp2, sizeof(tmp2), _("Unsubscribe pattern: "));
  /* buf comes from the buffer pool, so defaults to size 1024 */
  if ((mw_get_field(tmp2, buf, MUTT_COMP_NONE, HC_PATTERN, &CompletePatternOps, NULL) != 0) ||
      buf_is_empty(buf))
  {
    buf_pool_release(&buf);
    return FR_NO_ACTION;
  }
 
  int err = REG_COMP(&rx, buf->data, REG_NOSUB);
  if (err != 0)
  {
    regerror(err, &rx, buf->data, buf->dsize);
    regfree(&rx);
    mutt_error("%s", buf_string(buf));
    buf_pool_release(&buf);
    return FR_ERROR;
  }
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  index = 0;
  buf_pool_release(&buf);
 
  int rc = nntp_newsrc_parse(adata);
  if (rc < 0)
    return FR_ERROR;
 
  struct FolderFile *ff = NULL;
  ARRAY_FOREACH_FROM(ff, &priv->state.entry, index)
  {
    if (regexec(&rx, ff->name, 0, NULL, 0) == 0)
    {
      if (op == OP_SUBSCRIBE_PATTERN)
        mutt_newsgroup_subscribe(adata, ff->name);
      else
        mutt_newsgroup_unsubscribe(adata, ff->name);
    }
  }
 
  if (op == OP_SUBSCRIBE_PATTERN)
  {
    for (size_t j = 0; j < adata->groups_num; j++)
    {
      struct NntpMboxData *mdata = adata->groups_list[j];
      if (mdata && mdata->group && !mdata->subscribed)
      {
        if (regexec(&rx, mdata->group, 0, NULL, 0) == 0)
        {
          mutt_newsgroup_subscribe(adata, mdata->group);
          browser_add_folder(priv->menu, &priv->state, mdata->group, NULL, NULL, NULL, mdata);
        }
      }
    }
    init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
  }
  if (rc > 0)
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  nntp_newsrc_update(adata);
  nntp_clear_cache(adata);
  nntp_newsrc_close(adata);
  regfree(&rx);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_toggle_mailboxes()

int op_toggle_mailboxes ( struct BrowserPrivateData * priv, const struct KeyEvent * event )

static

Toggle whether to browse mailboxes or all files - Implements browser_function_t -.

This function handles:

• OP_BROWSER_GOTO_FOLDER
• OP_CHECK_NEW
• OP_TOGGLE_MAILBOXES

Definition at line 1377 of file functions.c.

{
  struct BrowserModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_BROWSER);
  if (priv->state.is_mailbox_list)
  {
    priv->last_selected_mailbox = menu_get_index(priv->menu);
  }
 
  const int op = event->op;
  if (op == OP_TOGGLE_MAILBOXES)
  {
    priv->state.is_mailbox_list = !priv->state.is_mailbox_list;
  }
 
  if (op == OP_BROWSER_GOTO_FOLDER)
  {
    /* When in mailboxes mode, disables this feature */
    const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
    if (c_folder)
    {
      mutt_debug(LL_DEBUG3, "= hit! Folder: %s, LastDir: %s\n", c_folder,
                 buf_string(&mod_data->last_dir));
      if (priv->goto_swapper[0] == '\0')
      {
        if (!mutt_str_equal(buf_string(&mod_data->last_dir), c_folder))
        {
          /* Stores into goto_swapper LastDir, and swaps to `$folder` */
          mutt_str_copy(priv->goto_swapper, buf_string(&mod_data->last_dir),
                        sizeof(priv->goto_swapper));
          buf_copy(&mod_data->last_dir_backup, &mod_data->last_dir);
          buf_strcpy(&mod_data->last_dir, c_folder);
        }
      }
      else
      {
        buf_copy(&mod_data->last_dir_backup, &mod_data->last_dir);
        buf_strcpy(&mod_data->last_dir, priv->goto_swapper);
        priv->goto_swapper[0] = '\0';
      }
    }
  }
  destroy_state(&priv->state);
  buf_reset(priv->prefix);
  priv->kill_prefix = false;
 
  if (priv->state.is_mailbox_list)
  {
    examine_mailboxes(priv->mailbox, priv->menu, &priv->state);
  }
  else if (imap_path_probe(buf_string(&mod_data->last_dir), NULL) == MUTT_IMAP)
  {
    init_state(&priv->state);
    priv->state.imap_browse = true;
    imap_browse(buf_string(&mod_data->last_dir), &priv->state);
    browser_sort(&priv->state);
  }
  else if (examine_directory(priv->mailbox, priv->menu, &priv->state,
                             buf_string(&mod_data->last_dir),
                             buf_string(priv->prefix)) == -1)
  {
    priv->done = true;
    return FR_ERROR;
  }
  init_menu(&priv->state, priv->menu, priv->mailbox, priv->sbar);
  if (priv->state.is_mailbox_list)
    menu_set_index(priv->menu, priv->last_selected_mailbox);
  return FR_ERROR;
}

Here is the call graph for this function: