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	preview_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	utilwin_repaint (struct MuttWindow *win)
	Repaint the Utility 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	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()

int cbar_repaint ( struct MuttWindow * win )

static

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

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

preview_repaint()

int preview_repaint ( struct MuttWindow * win )

static

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

Definition at line 332 of file preview.c.

{
  struct PreviewWindowData *wdata = win->wdata;
  draw_preview(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:

enter_repaint()

int enter_repaint ( struct MuttWindow * win )

static

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

Definition at line 181 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, NULL, &prompt_length);
 
  int width = win->state.cols - prompt_length - 1;
  if (width < 1)
    width = 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, 0, prompt_length);
    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, 0,
                     prompt_length +
                         mutt_mb_wcswidth(wdata->state->wbuf + wdata->state->begin,
                                          wdata->state->curpos - wdata->state->begin));
  }
 
  mutt_window_get_coords(win, &wdata->row, &wdata->col);
  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()

int env_repaint ( struct MuttWindow * win )

static

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

Definition at line 752 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()

int msgwin_repaint ( struct MuttWindow * win )

static

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

Definition at line 255 of file msgwin.c.

{
  struct MsgWinWindowData *wdata = win->wdata;
 
  const char *str = buf_string(wdata->text);
  const int max_rows = MIN(MSGWIN_MAX_ROWS, win->state.rows);
  for (int i = 0; i < max_rows; i++)
  {
    mutt_window_move(win, i, 0);
    if (ARRAY_EMPTY(&wdata->rows[i]))
    {
      mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
      mutt_window_clrtoeol(win);
      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_window_get_coords(win, &wdata->row, &wdata->col);
 
  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()

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:

utilwin_repaint()

int utilwin_repaint ( struct MuttWindow * win )

static

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

Draw the text on the bottom row of the window, so that it aligns with the last line of a multi-line Message Window.

Definition at line 97 of file utilwin.c.

{
  struct UtilWinData *priv = win->wdata;
 
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
  // Blank any extra rows above the bottom line
  for (int r = 0; r < (win->state.rows - 1); r++)
  {
    mutt_window_move(win, r, 0);
    mutt_window_clrtoeol(win);
  }
 
  int row = win->state.rows - 1;
  mutt_window_move(win, row, 0);
 
  if (priv->text)
    mutt_window_addstr(win, priv->text);
 
  mutt_window_clrtoeol(win);
 
  mutt_debug(LL_DEBUG5, "utilwin repaint done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

helpbar_repaint()

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 163 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()

int ibar_repaint ( struct MuttWindow * win )

static

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

Definition at line 141 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");
  struct GuiModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
  if (c_ts_enabled && mod_data && mod_data->ts_supported)
  {
    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()

int index_repaint ( struct MuttWindow * win )

static

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

Definition at line 603 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_NONE;
  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()

int menu_repaint ( struct MuttWindow * win )

static

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

Definition at line 94 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_NONE;
 
  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, menu->current - menu->top, arrow_width);
  }
  else if (c_braille_friendly)
  {
    mutt_window_move(menu->win, menu->current - menu->top, 0);
  }
  else
  {
    mutt_window_move(menu->win, menu->current - menu->top, menu->win->state.cols - 1);
  }
 
  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:

pager_repaint()

int pager_repaint ( struct MuttWindow * win )

static

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

Definition at line 135 of file pager.c.

{
  struct PagerPrivateData *priv = win->wdata;
  if (!priv || !priv->pview || !priv->pview->pdata)
    return 0;
 
  dump_pager(priv);
 
  /* Phase 1: Reflow the content if the window was resized or needs repopulating.
   * Reset all line metadata and re-display lines up to the current position. */
  const bool repopulate = (priv->cur_line > priv->lines_used);
  if ((priv->redraw & PAGER_REDRAW_FLOW) || repopulate)
  {
    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), 1, struct TextSyntax);
      priv->lines[i].syntax[0].attr_color = NULL;
      priv->lines[i].syntax[0].first = -1;
      priv->lines[i].syntax[0].last = -1;
 
      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;
      }
    }
  }
 
  /* Phase 2: Repaint visible lines from top_line downward.  Repeatedly
   * calls display_line() for each row in the pager window. */
  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, priv->win_height, 0);
      }
    } while (priv->force_redraw);
 
    /* Fill remaining rows with tilde characters (like vi) */
    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, priv->win_height, 0);
    }
    mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
  }
 
  priv->redraw = PAGER_REDRAW_NONE;
  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()

int pbar_repaint ( struct MuttWindow * win )

static

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

Definition at line 151 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()

int progress_window_repaint ( struct MuttWindow * win )

static

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

Definition at line 164 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 787 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, row, col);
      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: