repaint()

Repaint the Window. More...

Collaboration diagram for repaint():

Functions
static int	cbar_repaint (struct MuttWindow *win)
	Repaint the Window - Implements MuttWindow::repaint() -.
static int	enter_repaint (struct MuttWindow *win)
	Repaint the Window - Implements MuttWindow::repaint() -.
static int	env_repaint (struct MuttWindow *win)
	Repaint the Window - Implements MuttWindow::repaint() -.
static int	msgwin_repaint (struct MuttWindow *win)
	Redraw the Message Window - Implements MuttWindow::repaint() -.
static int	sbar_repaint (struct MuttWindow *win)
	Repaint the Window - Implements MuttWindow::repaint() -.
static int	helpbar_repaint (struct MuttWindow *win)
	Redraw the Help Bar - Implements MuttWindow::repaint() -.
static int	ibar_repaint (struct MuttWindow *win)
	Repaint the Window - Implements MuttWindow::repaint() -.
static int	index_repaint (struct MuttWindow *win)
	Repaint the Index display - Implements MuttWindow::repaint() -.
static int	menu_repaint (struct MuttWindow *win)
	Repaint the Window - Implements MuttWindow::repaint() -.
static int	win_chain_repaint (struct MuttWindow *win)
	Repaint the Chain list - Implements MuttWindow::repaint() -.
static int	pager_repaint (struct MuttWindow *win)
	Repaint the Pager display - Implements MuttWindow::repaint() -.
static int	pbar_repaint (struct MuttWindow *win)
	Repaint the Window - Implements MuttWindow::repaint() -.
static int	progress_window_repaint (struct MuttWindow *win)
	Repaint the Progress Bar - Implements MuttWindow::repaint() -.
int	sb_repaint (struct MuttWindow *win)
	Repaint the Sidebar display - Implements MuttWindow::repaint() -.

Detailed Description

Repaint the Window.

Parameters

win

Window

Return values

0	Success
-1	Error

Precondition

win is not NULL

win is visible

Function Documentation

cbar_repaint()

static int cbar_repaint ( struct MuttWindow *  win )

static

Repaint the Window - Implements MuttWindow::repaint() -.

Definition at line 184 of file cbar.c.

{
  struct ComposeBarData *cbar_data = win->wdata;
 
  mutt_window_move(win, 0, 0);
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_STATUS);
  mutt_window_clrtoeol(win);
 
  mutt_window_move(win, 0, 0);
  mutt_draw_statusline(win, win->state.cols, cbar_data->compose_format,
                       mutt_str_len(cbar_data->compose_format));
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
  mutt_debug(LL_DEBUG5, "repaint done\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

enter_repaint()

static int enter_repaint ( struct MuttWindow *  win )

static

Repaint the Window - Implements MuttWindow::repaint() -.

Definition at line 187 of file window.c.

{
  if (!mutt_window_is_visible(win))
    return 0;
 
  struct EnterWindowData *wdata = win->wdata;
 
  mutt_window_clearline(win, 0);
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_PROMPT);
  mutt_window_addstr(win, wdata->prompt);
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
  int prompt_length = 0;
  mutt_window_get_coords(win, &prompt_length, NULL);
 
  int width = win->state.cols - prompt_length - 1;
 
  if (!wdata->pass)
  {
    if (wdata->redraw == ENTER_REDRAW_INIT)
    {
      /* Go to end of line */
      wdata->state->curpos = wdata->state->lastchar;
      wdata->state->begin = mutt_mb_width_ceiling(
          wdata->state->wbuf, wdata->state->lastchar,
          mutt_mb_wcswidth(wdata->state->wbuf, wdata->state->lastchar) - width + 1);
    }
    if ((wdata->state->curpos < wdata->state->begin) ||
        (mutt_mb_wcswidth(wdata->state->wbuf + wdata->state->begin,
                          wdata->state->curpos - wdata->state->begin) >= width))
    {
      wdata->state->begin = mutt_mb_width_ceiling(
          wdata->state->wbuf, wdata->state->lastchar,
          mutt_mb_wcswidth(wdata->state->wbuf, wdata->state->curpos) - (width / 2));
    }
    mutt_window_move(win, prompt_length, 0);
    int w = 0;
    for (size_t i = wdata->state->begin; i < wdata->state->lastchar; i++)
    {
      w += mutt_mb_wcwidth(wdata->state->wbuf[i]);
      if (w > width)
        break;
      my_addwch(win, wdata->state->wbuf[i]);
    }
    mutt_window_clrtoeol(win);
    mutt_window_move(win,
                     prompt_length +
                         mutt_mb_wcswidth(wdata->state->wbuf + wdata->state->begin,
                                          wdata->state->curpos - wdata->state->begin),
                     0);
  }
 
  mutt_window_get_coords(win, &wdata->col, &wdata->row);
  mutt_debug(LL_DEBUG5, "repaint done\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

env_repaint()

static int env_repaint ( struct MuttWindow *  win )

static

Repaint the Window - Implements MuttWindow::repaint() -.

Definition at line 790 of file window.c.

{
  struct EnvelopeWindowData *wdata = win->wdata;
 
  draw_envelope(win, wdata);
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

msgwin_repaint()

static int msgwin_repaint ( struct MuttWindow *  win )

static

Redraw the Message Window - Implements MuttWindow::repaint() -.

Definition at line 251 of file msgwin.c.

{
  struct MsgWinWindowData *wdata = win->wdata;
 
  const char *str = buf_string(wdata->text);
  for (int i = 0; i < MSGWIN_MAX_ROWS; i++)
  {
    mutt_window_move(win, 0, i);
    if (ARRAY_EMPTY(&wdata->rows[i]))
      break;
 
    struct MwChunk *chunk = NULL;
    ARRAY_FOREACH(chunk, &wdata->rows[i])
    {
      mutt_curses_set_color(chunk->ac_color);
      mutt_window_addnstr(win, str + chunk->offset, chunk->bytes);
    }
    mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
    mutt_window_clrtoeol(win);
  }
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
  mutt_window_clrtoeol(win);
 
  mutt_window_get_coords(win, &wdata->col, &wdata->row);
 
  mutt_debug(LL_DEBUG5, "msgwin repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sbar_repaint()

static int sbar_repaint ( struct MuttWindow *  win )

static

Repaint the Window - Implements MuttWindow::repaint() -.

Definition at line 95 of file sbar.c.

{
  struct SBarPrivateData *priv = win->wdata;
 
  mutt_window_move(win, 0, 0);
 
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_STATUS);
  mutt_window_move(win, 0, 0);
  mutt_paddstr(win, win->state.cols, priv->display);
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

helpbar_repaint()

static int helpbar_repaint ( struct MuttWindow *  win )

static

Redraw the Help Bar - Implements MuttWindow::repaint() -.

The Help Bar is drawn from the data cached in the HelpbarWindowData. No calculation is performed.

Definition at line 179 of file helpbar.c.

{
  struct HelpbarWindowData *wdata = helpbar_wdata_get(win);
  if (!wdata)
    return 0;
 
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_STATUS);
  mutt_window_move(win, 0, 0);
  mutt_paddstr(win, win->state.cols, wdata->help_str);
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ibar_repaint()

static int ibar_repaint ( struct MuttWindow *  win )

static

Repaint the Window - Implements MuttWindow::repaint() -.

Definition at line 138 of file ibar.c.

{
  struct IBarPrivateData *ibar_data = win->wdata;
  struct IndexSharedData *shared = ibar_data->shared;
 
  mutt_window_move(win, 0, 0);
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_STATUS);
  mutt_window_clrtoeol(win);
 
  mutt_window_move(win, 0, 0);
  mutt_draw_statusline(win, win->state.cols, ibar_data->status_format,
                       mutt_str_len(ibar_data->status_format));
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
  const bool c_ts_enabled = cs_subset_bool(shared->sub, "ts_enabled");
  if (c_ts_enabled && TsSupported)
  {
    mutt_ts_status(ibar_data->ts_status_format);
    mutt_ts_icon(ibar_data->ts_icon_format);
  }
 
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_repaint()

static int index_repaint ( struct MuttWindow *  win )

static

Repaint the Index display - Implements MuttWindow::repaint() -.

Definition at line 544 of file index.c.

{
  struct Menu *menu = win->wdata;
 
  if (menu->redraw & MENU_REDRAW_FULL)
    menu_redraw_full(menu);
 
  // If we don't have the focus, then this is a mini-Index ($pager_index_lines)
  if (!window_is_focused(menu->win))
  {
    int indicator = menu->page_len / 3;
 
    /* some fudge to work out whereabouts the indicator should go */
    const int index = menu_get_index(menu);
    if ((index - indicator) < 0)
      menu->top = 0;
    else if ((menu->max - index) < (menu->page_len - indicator))
      menu->top = menu->max - menu->page_len;
    else
      menu->top = index - indicator;
  }
  menu_adjust(menu);
  menu->redraw = MENU_REDRAW_INDEX;
 
  struct IndexPrivateData *priv = menu->mdata;
  struct IndexSharedData *shared = priv->shared;
  struct Mailbox *m = shared->mailbox;
  const int index = menu_get_index(menu);
  if (m && m->emails && (index < m->vcount))
  {
    if (menu->redraw & MENU_REDRAW_INDEX)
    {
      menu_redraw_index(menu);
    }
    else if (menu->redraw & MENU_REDRAW_MOTION)
    {
      menu_redraw_motion(menu);
    }
    else if (menu->redraw & MENU_REDRAW_CURRENT)
    {
      menu_redraw_current(menu);
    }
  }
 
  menu->redraw = MENU_REDRAW_NO_FLAGS;
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_repaint()

static int menu_repaint ( struct MuttWindow *  win )

static

Repaint the Window - Implements MuttWindow::repaint() -.

Definition at line 93 of file window.c.

{
  if (win->type != WT_MENU)
    return 0;
 
  struct Menu *menu = win->wdata;
  menu->redraw |= MENU_REDRAW_FULL;
  menu_redraw(menu);
  menu->redraw = MENU_REDRAW_NO_FLAGS;
 
  const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
  const bool c_braille_friendly = cs_subset_bool(menu->sub, "braille_friendly");
 
  /* move the cursor out of the way */
  if (c_arrow_cursor)
  {
    const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
    const int arrow_width = mutt_strwidth(c_arrow_string);
    mutt_window_move(menu->win, arrow_width, menu->current - menu->top);
  }
  else if (c_braille_friendly)
  {
    mutt_window_move(menu->win, 0, menu->current - menu->top);
  }
  else
  {
    mutt_window_move(menu->win, menu->win->state.cols - 1, menu->current - menu->top);
  }
 
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

win_chain_repaint()

static int win_chain_repaint ( struct MuttWindow *  win )

static

Repaint the Chain list - Implements MuttWindow::repaint() -.

Definition at line 145 of file win_chain.c.

{
  for (int i = 0; i < win->state.rows; i++)
  {
    mutt_window_move(win, 0, i);
    mutt_window_clrtoeol(win);
  }
 
  struct ChainData *cd = win->wdata;
 
  if (cd->chain_len == 0)
    return 0;
 
  for (int i = 0; i < cd->chain_len; i++)
  {
    if (cd->coords[i].row < win->state.rows)
    {
      if (i == cd->sel)
        mutt_curses_set_color_by_id(MT_COLOR_INDICATOR);
      else
        mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
      int index = cd->chain[i];
      struct Remailer **rp = ARRAY_GET(cd->ra, index);
      mutt_window_mvaddstr(win, cd->coords[i].col, cd->coords[i].row, (*rp)->shortname);
      mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
      if ((i + 1) < cd->chain_len)
        mutt_window_addstr(win, ", ");
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pager_repaint()

static int pager_repaint ( struct MuttWindow *  win )

static

Repaint the Pager display - Implements MuttWindow::repaint() -.

Definition at line 129 of file pager.c.

{
  struct PagerPrivateData *priv = win->wdata;
  if (!priv || !priv->pview || !priv->pview->pdata)
    return 0;
 
  dump_pager(priv);
 
  // We need to populate more lines, but not change position
  const bool repopulate = (priv->cur_line > priv->lines_used);
  if ((priv->redraw & PAGER_REDRAW_FLOW) || repopulate)
  {
    if (!(priv->pview->flags & MUTT_PAGER_RETWINCH))
    {
      priv->win_height = -1;
      for (int i = 0; i <= priv->top_line; i++)
        if (!priv->lines[i].cont_line)
          priv->win_height++;
      for (int i = 0; i < priv->lines_max; i++)
      {
        priv->lines[i].offset = 0;
        priv->lines[i].cid = -1;
        priv->lines[i].cont_line = false;
        priv->lines[i].syntax_arr_size = 0;
        priv->lines[i].search_arr_size = -1;
        priv->lines[i].quote = NULL;
 
        mutt_mem_realloc(&(priv->lines[i].syntax), sizeof(struct TextSyntax));
        if (priv->search_compiled && priv->lines[i].search)
          FREE(&(priv->lines[i].search));
      }
 
      if (!repopulate)
      {
        priv->lines_used = 0;
        priv->top_line = 0;
      }
    }
    int i = -1;
    int j = -1;
    const PagerFlags flags = priv->has_types | priv->search_flag |
                             (priv->pview->flags & MUTT_PAGER_NOWRAP) |
                             (priv->pview->flags & MUTT_PAGER_STRIPES);
 
    while (display_line(priv->fp, &priv->bytes_read, &priv->lines, ++i,
                        &priv->lines_used, &priv->lines_max, flags, &priv->quote_list,
                        &priv->q_level, &priv->force_redraw, &priv->search_re,
                        priv->pview->win_pager, &priv->ansi_list) == 0)
    {
      if (!priv->lines[i].cont_line && (++j == priv->win_height))
      {
        if (!repopulate)
          priv->top_line = i;
        if (!priv->search_flag)
          break;
      }
    }
  }
 
  if ((priv->redraw & PAGER_REDRAW_PAGER) || (priv->top_line != priv->old_top_line))
  {
    do
    {
      mutt_window_move(priv->pview->win_pager, 0, 0);
      priv->cur_line = priv->top_line;
      priv->old_top_line = priv->top_line;
      priv->win_height = 0;
      priv->force_redraw = false;
 
      while ((priv->win_height < priv->pview->win_pager->state.rows) &&
             (priv->lines[priv->cur_line].offset <= priv->st.st_size - 1))
      {
        const PagerFlags flags = (priv->pview->flags & MUTT_DISPLAYFLAGS) |
                                 priv->hide_quoted | priv->search_flag |
                                 (priv->pview->flags & MUTT_PAGER_NOWRAP) |
                                 (priv->pview->flags & MUTT_PAGER_STRIPES);
 
        if (display_line(priv->fp, &priv->bytes_read, &priv->lines, priv->cur_line,
                         &priv->lines_used, &priv->lines_max, flags, &priv->quote_list,
                         &priv->q_level, &priv->force_redraw, &priv->search_re,
                         priv->pview->win_pager, &priv->ansi_list) > 0)
        {
          priv->win_height++;
        }
        priv->cur_line++;
        mutt_window_move(priv->pview->win_pager, 0, priv->win_height);
      }
    } while (priv->force_redraw);
 
    const bool c_tilde = cs_subset_bool(NeoMutt->sub, "tilde");
    mutt_curses_set_normal_backed_color_by_id(MT_COLOR_TILDE);
    while (priv->win_height < priv->pview->win_pager->state.rows)
    {
      mutt_window_clrtoeol(priv->pview->win_pager);
      if (c_tilde)
        mutt_window_addch(priv->pview->win_pager, '~');
      priv->win_height++;
      mutt_window_move(priv->pview->win_pager, 0, priv->win_height);
    }
    mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
  }
 
  priv->redraw = PAGER_REDRAW_NO_FLAGS;
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pbar_repaint()

static int pbar_repaint ( struct MuttWindow *  win )

static

Repaint the Window - Implements MuttWindow::repaint() -.

Definition at line 154 of file pbar.c.

{
  struct PBarPrivateData *pbar_data = win->wdata;
 
  mutt_window_move(win, 0, 0);
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_STATUS);
  mutt_window_clrtoeol(win);
 
  mutt_window_move(win, 0, 0);
  mutt_draw_statusline(win, win->state.cols, pbar_data->pager_format,
                       mutt_str_len(pbar_data->pager_format));
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

progress_window_repaint()

static int progress_window_repaint ( struct MuttWindow *  win )

static

Repaint the Progress Bar - Implements MuttWindow::repaint() -.

Definition at line 157 of file window.c.

{
  if (!win || !win->wdata)
    return -1;
 
  struct ProgressWindowData *wdata = win->wdata;
  if (wdata->msg[0] == '\0')
    return 0;
 
  if (wdata->size == 0)
  {
    if (wdata->display_percent >= 0)
    {
      if (wdata->is_bytes)
      {
        /* L10N: Progress bar: `%s` loading text, `%s` pretty size (e.g. 4.6K),
           `%d` is the number, `%%` is the percent symbol.
           `%d` and `%%` may be reordered, or space inserted, if you wish. */
        message_bar(wdata->win, wdata->display_percent, _("%s %s (%d%%)"),
                    wdata->msg, wdata->pretty_pos, wdata->display_percent);
      }
      else
      {
        /* L10N: Progress bar: `%s` loading text, `%zu` position,
           `%d` is the number, `%%` is the percent symbol.
           `%d` and `%%` may be reordered, or space inserted, if you wish. */
        message_bar(wdata->win, wdata->display_percent, _("%s %zu (%d%%)"),
                    wdata->msg, wdata->display_pos, wdata->display_percent);
      }
    }
    else
    {
      if (wdata->is_bytes)
      {
        /* L10N: Progress bar: `%s` loading text, `%s` position/size */
        message_bar(wdata->win, -1, _("%s %s"), wdata->msg, wdata->pretty_pos);
      }
      else
      {
        /* L10N: Progress bar: `%s` loading text, `%zu` position */
        message_bar(wdata->win, -1, _("%s %zu"), wdata->msg, wdata->display_pos);
      }
    }
  }
  else
  {
    if (wdata->is_bytes)
    {
      /* L10N: Progress bar: `%s` loading text, `%s/%s` position/size,
         `%d` is the number, `%%` is the percent symbol.
         `%d` and `%%` may be reordered, or space inserted, if you wish. */
      message_bar(wdata->win, wdata->display_percent, _("%s %s/%s (%d%%)"),
                  wdata->msg, wdata->pretty_pos, wdata->pretty_size, wdata->display_percent);
    }
    else
    {
      /* L10N: Progress bar: `%s` loading text, `%zu/%zu` position/size,
         `%d` is the number, `%%` is the percent symbol.
         `%d` and `%%` may be reordered, or space inserted, if you wish. */
      message_bar(wdata->win, wdata->display_percent, _("%s %zu/%zu (%d%%)"),
                  wdata->msg, wdata->display_pos, wdata->size, wdata->display_percent);
    }
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_repaint()

int sb_repaint

(

struct MuttWindow *

win

)

Repaint the Sidebar display - Implements MuttWindow::repaint() -.

Definition at line 959 of file window.c.

{
  struct SidebarWindowData *wdata = sb_wdata_get(win);
  const bool c_sidebar_on_right = cs_subset_bool(NeoMutt->sub, "sidebar_on_right");
 
  int row = 0;
  int num_rows = win->state.rows;
  int num_cols = win->state.cols;
 
  if (wdata->top_index >= 0)
  {
    int col = 0;
    if (c_sidebar_on_right)
      col = wdata->divider_width;
 
    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);
      mutt_window_move(win, col, row);
      mutt_curses_set_color(entry->color);
      mutt_window_printf(win, "%s", entry->display);
      mutt_refresh();
      row++;
    }
  }
 
  fill_empty_space(win, row, num_rows - row, wdata->divider_width,
                   num_cols - wdata->divider_width);
  draw_divider(wdata, win, num_rows, num_cols);
 
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: