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() -. More...
static int	cbar_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -. More...
static int	env_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -. More...
static int	msgwin_recalc (struct MuttWindow *win)
	Recalculate the display of the Message Window - Implements MuttWindow::recalc() -. More...
static int	sbar_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -. More...
static int	helpbar_recalc (struct MuttWindow *win)
	Recalculate the display of the Help Bar - Implements MuttWindow::recalc() -. More...
static int	ibar_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -. More...
static int	index_recalc (struct MuttWindow *win)
	Recalculate the Index display - Implements MuttWindow::recalc() -. More...
static int	menu_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -. More...
static int	win_chain_recalc (struct MuttWindow *win)
	Recalculate the Chain list - Implements MuttWindow::recalc() -. More...
static int	pager_recalc (struct MuttWindow *win)
	Recalculate the Pager display - Implements MuttWindow::recalc() -. More...
static int	pbar_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -. More...
static int	progress_window_recalc (struct MuttWindow *win)
	Recalculate the Progress Bar - Implements MuttWindow::recalc() -. More...
int	sb_recalc (struct MuttWindow *win)
	Recalculate the Sidebar display - Implements MuttWindow::recalc() -. More...

Detailed Description

Recalculate the Window data.

Parameters

win

Window

Return values

0	Success
-1	Error

Function Documentation

alias_recalc()

int alias_recalc

(

struct MuttWindow *

win

)

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

Definition at line 89 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:

cbar_recalc()

static int cbar_recalc ( struct MuttWindow *  win )

static

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

See also

$compose_format, compose_format_str()

Definition at line 161 of file cbar.c.

{
  char buf[1024] = { 0 };
  struct ComposeSharedData *shared = win->parent->wdata;
 
  const char *const c_compose_format = cs_subset_string(shared->sub, "compose_format");
  mutt_expando_format(buf, sizeof(buf), 0, win->state.cols, NONULL(c_compose_format),
                      compose_format_str, (intptr_t) shared, MUTT_FORMAT_NO_FLAGS);
 
  struct ComposeBarData *cbar_data = win->wdata;
  if (!mutt_str_equal(buf, cbar_data->compose_format))
  {
    mutt_str_replace(&cbar_data->compose_format, buf);
    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:

env_recalc()

static int env_recalc ( struct MuttWindow *  win )

static

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

Definition at line 769 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 102 of file msgwin.c.

{
  if (window_is_focused(win)) // Someone else is using it
    return 0;
 
  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:

sbar_recalc()

static int sbar_recalc ( struct MuttWindow *  win )

static

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

Definition at line 80 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 142 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;
 
  char helpstr[1024] = { 0 };
  compile_help(helpstr, sizeof(helpstr), win_focus->help_menu, win_focus->help_data);
 
  wdata->help_menu = win_focus->help_menu;
  wdata->help_data = win_focus->help_data;
  wdata->help_str = mutt_str_dup(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 89 of file ibar.c.

{
  char buf[1024] = { 0 };
 
  struct IBarPrivateData *ibar_data = win->wdata;
  struct IndexSharedData *shared = ibar_data->shared;
  struct IndexPrivateData *priv = ibar_data->priv;
 
  const char *c_status_format = cs_subset_string(shared->sub, "status_format");
  menu_status_line(buf, sizeof(buf), shared, priv->menu, win->state.cols,
                   NONULL(c_status_format));
 
  if (!mutt_str_equal(buf, ibar_data->status_format))
  {
    mutt_str_replace(&ibar_data->status_format, 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)
  {
    const char *c_ts_status_format = cs_subset_string(shared->sub, "ts_status_format");
    menu_status_line(buf, sizeof(buf), shared, priv->menu, sizeof(buf),
                     NONULL(c_ts_status_format));
    if (!mutt_str_equal(buf, ibar_data->ts_status_format))
    {
      mutt_str_replace(&ibar_data->ts_status_format, buf);
      win->actions |= WA_REPAINT;
      mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
    }
 
    const char *c_ts_icon_format = cs_subset_string(shared->sub, "ts_icon_format");
    menu_status_line(buf, sizeof(buf), shared, priv->menu, sizeof(buf),
                     NONULL(c_ts_icon_format));
    if (!mutt_str_equal(buf, ibar_data->ts_icon_format))
    {
      mutt_str_replace(&ibar_data->ts_icon_format, buf);
      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:

index_recalc()

static int index_recalc ( struct MuttWindow *  win )

static

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

Definition at line 527 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;
 
  // struct Menu *menu = win->wdata;
 
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

Here is the caller graph for this function:

win_chain_recalc()

static int win_chain_recalc ( struct MuttWindow *  win )

static

Recalculate the Chain list - Implements MuttWindow::recalc() -.

Definition at line 106 of file win_chain.c.

{
  const int wrap_indent = 2;
 
  if (!win || !win->wdata)
    return 0;
 
  struct ChainData *cd = win->wdata;
  cbar_update(cd);
 
  win->actions |= WA_REPAINT;
  if (cd->chain_len == 0)
    return 0;
 
  short col = 0, row = 0;
  for (int i = 0; i < cd->chain_len; i++)
  {
    short old_col = col;
    int index = cd->chain[i];
    struct Remailer **rp = ARRAY_GET(cd->ra, index);
    col += strlen((*rp)->shortname) + 2;
 
    if (col >= win->state.cols)
    {
      old_col = wrap_indent;
      col = wrap_indent;
      row++;
    }
 
    cd->coords[i].col = old_col;
    cd->coords[i].row = row;
  }
 
  return 0;
}

Here is the call graph for this function:

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 123 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 93 of file pbar.c.

{
  char buf[1024] = { 0 };
 
  struct PBarPrivateData *pbar_data = win->wdata;
  struct IndexSharedData *shared = pbar_data->shared;
  struct PagerPrivateData *priv = pbar_data->priv;
  if (!priv || !priv->pview)
    return 0;
 
  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))
  {
    snprintf(pager_progress_str, sizeof(pager_progress_str), OFF_T_FMT "%%",
             (100 * offset / priv->st.st_size));
  }
  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->mailboxview ? shared->mailboxview->msg_in_pager : -1;
 
    const char *c_pager_format = cs_subset_string(shared->sub, "pager_format");
    mutt_make_string(buf, sizeof(buf), win->state.cols, NONULL(c_pager_format),
                     shared->mailbox, msg_in_pager, shared->email,
                     MUTT_FORMAT_NO_FLAGS, pager_progress_str);
  }
  else
  {
    snprintf(buf, sizeof(buf), "%s (%s)", priv->pview->banner, pager_progress_str);
  }
 
  if (!mutt_str_equal(buf, pbar_data->pager_format))
  {
    mutt_str_replace(&pbar_data->pager_format, buf);
    win->actions |= WA_REPAINT;
  }
 
  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 132 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)
    mutt_str_pretty_size(wdata->pretty_pos, sizeof(wdata->pretty_pos), wdata->display_pos);
 
  if (wdata->update_percent < 0)
    wdata->display_percent = 100.0 * 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 713 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;
    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: