recalc()

Recalculate the Window data. More...

Collaboration diagram for recalc():

Functions
int	alias_recalc (struct MuttWindow *win)
	Recalculate the display of the Alias Window - Implements MuttWindow::recalc() -.
static int	attach_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	cbar_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	compose_recalc (struct MuttWindow *dlg)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	preview_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	enter_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	env_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	msgwin_recalc (struct MuttWindow *win)
	Recalculate the display of the Message Window - Implements MuttWindow::recalc() -.
static int	sbar_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	helpbar_recalc (struct MuttWindow *win)
	Recalculate the display of the Help Bar - Implements MuttWindow::recalc() -.
static int	ibar_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	index_recalc (struct MuttWindow *win)
	Recalculate the Index display - Implements MuttWindow::recalc() -.
static int	menu_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	pager_recalc (struct MuttWindow *win)
	Recalculate the Pager display - Implements MuttWindow::recalc() -.
static int	pbar_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	progress_window_recalc (struct MuttWindow *win)
	Recalculate the Progress Bar - Implements MuttWindow::recalc() -.
int	sb_recalc (struct MuttWindow *win)
	Recalculate the Sidebar display - Implements MuttWindow::recalc() -.

Detailed Description

Recalculate the Window data.

Parameters

win

Window

Return values

0	Success
-1	Error

Precondition

win is not NULL

win is visible

Function Documentation

alias_recalc()

int alias_recalc

(

struct MuttWindow *

win

)

Recalculate the display of the Alias Window - Implements MuttWindow::recalc() -.

Definition at line 92 of file gui.c.

{
  struct Menu *menu = win->wdata;
  struct AliasMenuData *mdata = menu->mdata;
 
  alias_array_sort(&mdata->ava, mdata->sub);
 
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_recalc()

static int attach_recalc ( struct MuttWindow *  win )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 243 of file attach.c.

{
  struct Menu *menu = win->wdata;
  struct ComposeAttachData *adata = menu->mdata;
 
  const int cur_rows = win->state.rows;
  const int new_rows = adata->actx->idxlen;
 
  if (new_rows != cur_rows)
  {
    win->req_rows = new_rows;
    mutt_window_reflow(win->parent);
    menu_adjust(menu);
  }
 
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cbar_recalc()

static int cbar_recalc ( struct MuttWindow *  win )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

See also

$compose_format

Definition at line 81 of file cbar.c.

{
  struct Buffer *buf = buf_pool_get();
  struct ComposeSharedData *shared = win->parent->wdata;
 
  const struct Expando *c_compose_format = cs_subset_expando(shared->sub, "compose_format");
  expando_filter(c_compose_format, ComposeRenderCallbacks, shared,
                 MUTT_FORMAT_NO_FLAGS, win->state.cols, NeoMutt->env, buf);
 
  struct ComposeBarData *cbar_data = win->wdata;
  if (!mutt_str_equal(buf_string(buf), cbar_data->compose_format))
  {
    mutt_str_replace(&cbar_data->compose_format, buf_string(buf));
    win->actions |= WA_REPAINT;
    mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  }
  buf_pool_release(&buf);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compose_recalc()

static int compose_recalc ( struct MuttWindow *  dlg )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 127 of file dlg_compose.c.

{
  if (!dlg)
    return -1;
 
  struct ComposeSharedData *shared = dlg->wdata;
  struct MuttWindow *win_env = window_find_child(dlg, WT_CUSTOM);
  struct MuttWindow *win_preview = shared->win_preview;
  struct MuttWindow *win_preview_bar = shared->win_preview_bar;
 
  const bool c_show_preview = cs_subset_bool(shared->sub, "compose_show_preview");
  const short c_preview_min_rows = cs_subset_number(shared->sub, "compose_preview_min_rows");
 
  // How many rows are available for the preview window?
  // Total rows - (envelope window + attachments + number of status bars)
  int rows_available = dlg->state.rows -
                       (win_env->state.rows + shared->adata->actx->idxlen + 3);
 
  if (c_show_preview && rows_available >= c_preview_min_rows)
  {
    window_set_visible(win_preview, true);
    window_set_visible(win_preview_bar, true);
    attachment_size_fixed(shared->adata->menu->win);
  }
  else
  {
    window_set_visible(win_preview, false);
    window_set_visible(win_preview_bar, false);
    attachment_size_max(shared->adata->menu->win);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

preview_recalc()

static int preview_recalc ( struct MuttWindow *  win )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 327 of file preview.c.

{
  if (!win)
    return -1;
 
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the caller graph for this function:

enter_recalc()

static int enter_recalc ( struct MuttWindow *  win )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

See also

$compose_format

Definition at line 175 of file window.c.

{
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
 
  return 0;
}

Here is the caller graph for this function:

env_recalc()

static int env_recalc ( struct MuttWindow *  win )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 722 of file window.c.

{
  struct EnvelopeWindowData *wdata = win->wdata;
 
  const int cur_rows = win->state.rows;
  const int new_rows = calc_envelope(win, wdata);
 
  if (new_rows != cur_rows)
  {
    win->req_rows = new_rows;
    mutt_window_reflow(win->parent);
  }
 
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

msgwin_recalc()

static int msgwin_recalc ( struct MuttWindow *  win )

static

Recalculate the display of the Message Window - Implements MuttWindow::recalc() -.

Definition at line 161 of file msgwin.c.

{
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the caller graph for this function:

sbar_recalc()

static int sbar_recalc ( struct MuttWindow *  win )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 82 of file sbar.c.

{
  if (!win)
    return -1;
 
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the caller graph for this function:

helpbar_recalc()

static int helpbar_recalc ( struct MuttWindow *  win )

static

Recalculate the display of the Help Bar - Implements MuttWindow::recalc() -.

Generate the help string from data on the focused Window. The Help Bar isn't drawn, yet.

Definition at line 125 of file helpbar.c.

{
  struct HelpbarWindowData *wdata = helpbar_wdata_get(win);
  if (!wdata)
    return 0;
 
  FREE(&wdata->help_str);
 
  struct MuttWindow *win_focus = window_get_focus();
  if (!win_focus)
    return 0;
 
  // Ascend the Window tree until we find help_data
  while (win_focus && !win_focus->help_data)
    win_focus = win_focus->parent;
 
  if (!win_focus)
    return 0;
 
  struct Buffer *helpstr = buf_pool_get();
  compile_help(win_focus->help_menu, win_focus->help_data, helpstr);
 
  wdata->help_menu = win_focus->help_menu;
  wdata->help_data = win_focus->help_data;
  wdata->help_str = buf_strdup(helpstr);
  buf_pool_release(&helpstr);
 
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ibar_recalc()

static int ibar_recalc ( struct MuttWindow *  win )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 91 of file ibar.c.

{
  struct Buffer *buf = buf_pool_get();
 
  struct IBarPrivateData *ibar_data = win->wdata;
  struct IndexSharedData *shared = ibar_data->shared;
  struct IndexPrivateData *priv = ibar_data->priv;
 
  const struct Expando *c_status_format = cs_subset_expando(shared->sub, "status_format");
  menu_status_line(buf, shared, priv->menu, win->state.cols, c_status_format);
 
  if (!mutt_str_equal(buf_string(buf), ibar_data->status_format))
  {
    mutt_str_replace(&ibar_data->status_format, buf_string(buf));
    win->actions |= WA_REPAINT;
    mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  }
 
  const bool c_ts_enabled = cs_subset_bool(shared->sub, "ts_enabled");
  if (c_ts_enabled && TsSupported)
  {
    buf_reset(buf);
    const struct Expando *c_ts_status_format = cs_subset_expando(shared->sub, "ts_status_format");
    menu_status_line(buf, shared, priv->menu, -1, c_ts_status_format);
    if (!mutt_str_equal(buf_string(buf), ibar_data->ts_status_format))
    {
      mutt_str_replace(&ibar_data->ts_status_format, buf_string(buf));
      win->actions |= WA_REPAINT;
      mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
    }
 
    buf_reset(buf);
    const struct Expando *c_ts_icon_format = cs_subset_expando(shared->sub, "ts_icon_format");
    menu_status_line(buf, shared, priv->menu, -1, c_ts_icon_format);
    if (!mutt_str_equal(buf_string(buf), ibar_data->ts_icon_format))
    {
      mutt_str_replace(&ibar_data->ts_icon_format, buf_string(buf));
      win->actions |= WA_REPAINT;
      mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
    }
  }
 
  buf_pool_release(&buf);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_recalc()

static int index_recalc ( struct MuttWindow *  win )

static

Recalculate the Index display - Implements MuttWindow::recalc() -.

Definition at line 593 of file index.c.

{
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the caller graph for this function:

menu_recalc()

static int menu_recalc ( struct MuttWindow *  win )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 80 of file window.c.

{
  if (win->type != WT_MENU)
    return 0;
 
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the caller graph for this function:

pager_recalc()

static int pager_recalc ( struct MuttWindow *  win )

static

Recalculate the Pager display - Implements MuttWindow::recalc() -.

Definition at line 122 of file pager.c.

{
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the caller graph for this function:

pbar_recalc()

static int pbar_recalc ( struct MuttWindow *  win )

static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 91 of file pbar.c.

{
  struct PBarPrivateData *pbar_data = win->wdata;
  struct IndexSharedData *shared = pbar_data->shared;
  struct PagerPrivateData *priv = pbar_data->priv;
  if (!priv || !priv->pview)
    return 0;
 
  struct Buffer *buf = buf_pool_get();
  char pager_progress_str[65] = { 0 }; /* Lots of space for translations */
 
  long offset;
  if (priv->lines && (priv->cur_line <= priv->lines_used))
    offset = priv->lines[priv->cur_line].offset;
  else
    offset = priv->bytes_read;
 
  if (offset < (priv->st.st_size - 1))
  {
    const long percent = (100 * offset) / priv->st.st_size;
    /* L10N: Pager position percentage.
       `%ld` is the number, `%%` is the percent symbol.
       They may be reordered, or space inserted, if you wish. */
    snprintf(pager_progress_str, sizeof(pager_progress_str), _("%ld%%"), percent);
  }
  else
  {
    const char *msg = (priv->top_line == 0) ?
                          /* L10N: Status bar message: the entire email is visible in the pager */
                          _("all") :
                          /* L10N: Status bar message: the end of the email is visible in the pager */
                          _("end");
    mutt_str_copy(pager_progress_str, msg, sizeof(pager_progress_str));
  }
 
  if ((priv->pview->mode == PAGER_MODE_EMAIL) || (priv->pview->mode == PAGER_MODE_ATTACH_E))
  {
    int msg_in_pager = shared->mailbox_view ? shared->mailbox_view->msg_in_pager : -1;
 
    const struct Expando *c_pager_format = cs_subset_expando(shared->sub, "pager_format");
    mutt_make_string(buf, win->state.cols, c_pager_format, shared->mailbox, msg_in_pager,
                     shared->email, MUTT_FORMAT_NO_FLAGS, pager_progress_str);
  }
  else
  {
    buf_printf(buf, "%s (%s)", priv->pview->banner, pager_progress_str);
  }
 
  if (!mutt_str_equal(buf_string(buf), pbar_data->pager_format))
  {
    mutt_str_replace(&pbar_data->pager_format, buf_string(buf));
    win->actions |= WA_REPAINT;
  }
 
  buf_pool_release(&buf);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

progress_window_recalc()

static int progress_window_recalc ( struct MuttWindow *  win )

static

Recalculate the Progress Bar - Implements MuttWindow::recalc() -.

Definition at line 135 of file window.c.

{
  if (!win || !win->wdata)
    return -1;
 
  struct ProgressWindowData *wdata = win->wdata;
  wdata->display_pos = wdata->update_pos;
  wdata->display_time = wdata->update_time;
 
  if (wdata->is_bytes)
  {
    struct Buffer *pretty = buf_pool_get();
    mutt_str_pretty_size(pretty, wdata->display_pos);
    mutt_str_copy(wdata->pretty_pos, buf_string(pretty), sizeof(wdata->pretty_pos));
    buf_pool_release(&pretty);
  }
 
  if ((wdata->update_percent < 0) && (wdata->size != 0))
    wdata->display_percent = 100 * wdata->display_pos / wdata->size;
  else
    wdata->display_percent = wdata->update_percent;
 
  win->actions |= WA_REPAINT;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_recalc()

int sb_recalc

(

struct MuttWindow *

win

)

Recalculate the Sidebar display - Implements MuttWindow::recalc() -.

Definition at line 506 of file window.c.

{
  struct SidebarWindowData *wdata = sb_wdata_get(win);
  struct IndexSharedData *shared = wdata->shared;
 
  if (ARRAY_EMPTY(&wdata->entries))
  {
    struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
    neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
    struct MailboxNode *np = NULL;
    STAILQ_FOREACH(np, &ml, entries)
    {
      if (np->mailbox->visible)
        sb_add_mailbox(wdata, np->mailbox);
    }
    neomutt_mailboxlist_clear(&ml);
  }
 
  if (!prepare_sidebar(wdata, win->state.rows))
  {
    win->actions |= WA_REPAINT;
    return 0;
  }
 
  int num_rows = win->state.rows;
  int num_cols = win->state.cols;
 
  if (ARRAY_EMPTY(&wdata->entries) || (num_rows <= 0))
    return 0;
 
  if (wdata->top_index < 0)
    return 0;
 
  int width = num_cols - wdata->divider_width;
  int row = 0;
  struct Mailbox *m_cur = shared->mailbox;
  struct SbEntry **sbep = NULL;
  ARRAY_FOREACH_FROM(sbep, &wdata->entries, wdata->top_index)
  {
    if (row >= num_rows)
      break;
 
    if ((*sbep)->is_hidden)
      continue;
 
    struct SbEntry *entry = (*sbep);
    struct Mailbox *m = entry->mailbox;
 
    const int entryidx = ARRAY_FOREACH_IDX_sbep;
    entry->color = calc_color(m, (entryidx == wdata->opn_index),
                              (entryidx == wdata->hil_index));
 
    if (m_cur && (m_cur->realpath[0] != '\0') &&
        mutt_str_equal(m->realpath, m_cur->realpath))
    {
      m->msg_unread = m_cur->msg_unread;
      m->msg_count = m_cur->msg_count;
      m->msg_flagged = m_cur->msg_flagged;
    }
 
    const char *path = mailbox_path(m);
 
    const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
    // Try to abbreviate the full path
    const char *abbr = abbrev_folder(path, c_folder, m->type);
    if (!abbr)
      abbr = abbrev_url(path, m->type);
    const char *short_path = abbr ? abbr : path;
 
    /* Compute the depth */
    const char *last_part = abbr;
    const char *const c_sidebar_delim_chars = cs_subset_string(NeoMutt->sub, "sidebar_delim_chars");
    entry->depth = calc_path_depth(abbr, c_sidebar_delim_chars, &last_part);
 
    const bool short_path_is_abbr = (short_path == abbr);
    const bool c_sidebar_short_path = cs_subset_bool(NeoMutt->sub, "sidebar_short_path");
    if (c_sidebar_short_path)
    {
      short_path = last_part;
    }
 
    // Don't indent if we were unable to create an abbreviation.
    // Otherwise, the full path will be indent, and it looks unusual.
    const bool c_sidebar_folder_indent = cs_subset_bool(NeoMutt->sub, "sidebar_folder_indent");
    if (c_sidebar_folder_indent && short_path_is_abbr)
    {
      const short c_sidebar_component_depth = cs_subset_number(NeoMutt->sub, "sidebar_component_depth");
      if (c_sidebar_component_depth > 0)
        entry->depth -= c_sidebar_component_depth;
    }
    else if (!c_sidebar_folder_indent)
    {
      entry->depth = 0;
    }
 
    mutt_str_copy(entry->box, short_path, sizeof(entry->box));
    make_sidebar_entry(entry->display, sizeof(entry->display), width, entry, shared);
    row++;
  }
 
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: