NeoMutt  2024-04-25-127-g771158
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
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 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
winWindow
Return values
0Success
-1Error
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 177 of file cbar.c.

178{
179 struct ComposeBarData *cbar_data = win->wdata;
180
181 mutt_window_move(win, 0, 0);
184
185 mutt_window_move(win, 0, 0);
186 mutt_draw_statusline(win, win->state.cols, cbar_data->compose_format,
187 mutt_str_len(cbar_data->compose_format));
189 mutt_debug(LL_DEBUG5, "repaint done\n");
190
191 return 0;
192}
@ MT_COLOR_STATUS
Status bar (takes a pattern)
Definition: color.h:75
@ MT_COLOR_NORMAL
Plain text.
Definition: color.h:59
void mutt_draw_statusline(struct MuttWindow *win, int max_cols, const char *buf, size_t buflen)
Draw a highlighted status bar.
Definition: dlg_index.c:929
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
const struct AttrColor * mutt_curses_set_normal_backed_color_by_id(enum ColorId cid)
Set the colour and attributes by the colour id.
Definition: mutt_curses.c:63
const struct AttrColor * mutt_curses_set_color_by_id(enum ColorId cid)
Set the colour and attributes by the colour id.
Definition: mutt_curses.c:79
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:296
void mutt_window_clrtoeol(struct MuttWindow *win)
Clear to the end of the line.
Definition: mutt_window.c:243
Data to fill the Compose Bar Window.
Definition: cbar_data.h:34
char * compose_format
Cached status string.
Definition: cbar_data.h:35
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:126
void * wdata
Private data.
Definition: mutt_window.h:144
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
+ 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 186 of file window.c.

187{
188 if (!mutt_window_is_visible(win))
189 return 0;
190
191 struct EnterWindowData *wdata = win->wdata;
192
193 mutt_window_clearline(win, 0);
195 mutt_window_addstr(win, wdata->prompt);
197
198 int prompt_length = 0;
199 mutt_window_get_coords(win, &prompt_length, NULL);
200
201 int width = win->state.cols - prompt_length - 1;
202
203 if (!wdata->pass)
204 {
205 if (wdata->redraw == ENTER_REDRAW_INIT)
206 {
207 /* Go to end of line */
208 wdata->state->curpos = wdata->state->lastchar;
210 wdata->state->wbuf, wdata->state->lastchar,
211 mutt_mb_wcswidth(wdata->state->wbuf, wdata->state->lastchar) - width + 1);
212 }
213 if ((wdata->state->curpos < wdata->state->begin) ||
214 (mutt_mb_wcswidth(wdata->state->wbuf + wdata->state->begin,
215 wdata->state->curpos - wdata->state->begin) >= width))
216 {
218 wdata->state->wbuf, wdata->state->lastchar,
219 mutt_mb_wcswidth(wdata->state->wbuf, wdata->state->curpos) - (width / 2));
220 }
221 mutt_window_move(win, prompt_length, 0);
222 int w = 0;
223 for (size_t i = wdata->state->begin; i < wdata->state->lastchar; i++)
224 {
225 w += mutt_mb_wcwidth(wdata->state->wbuf[i]);
226 if (w > width)
227 break;
228 my_addwch(win, wdata->state->wbuf[i]);
229 }
232 prompt_length +
233 mutt_mb_wcswidth(wdata->state->wbuf + wdata->state->begin,
234 wdata->state->curpos - wdata->state->begin),
235 0);
236 }
237
238 mutt_window_get_coords(win, &wdata->col, &wdata->row);
239 mutt_debug(LL_DEBUG5, "repaint done\n");
240
241 return 0;
242}
@ MT_COLOR_PROMPT
Question/user input.
Definition: color.h:62
@ ENTER_REDRAW_INIT
Go to end of line and redraw.
Definition: wdata.h:38
static int my_addwch(struct MuttWindow *win, wchar_t wc)
Display one wide character on screen.
Definition: window.c:71
size_t mutt_mb_width_ceiling(const wchar_t *s, size_t n, int w1)
Keep the end of the string on-screen.
Definition: mbyte.c:237
int mutt_mb_wcswidth(const wchar_t *s, size_t n)
Measure the screen width of a string.
Definition: mbyte.c:216
int mutt_mb_wcwidth(wchar_t wc)
Measure the screen width of a character.
Definition: mbyte.c:198
bool mutt_window_is_visible(struct MuttWindow *win)
Is the Window visible?
Definition: mutt_window.c:511
void mutt_window_get_coords(struct MuttWindow *win, int *col, int *row)
Get the cursor position in the Window.
Definition: mutt_window.c:276
void mutt_window_clearline(struct MuttWindow *win, int row)
Clear a row of a Window.
Definition: mutt_window.c:231
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition: mutt_window.c:415
size_t curpos
Position of the cursor.
Definition: state.h:36
size_t begin
Position of the start.
Definition: state.h:37
wchar_t * wbuf
Buffer for the string being entered.
Definition: state.h:33
size_t lastchar
Position of the last character.
Definition: state.h:35
Data to fill the Enter Window.
Definition: wdata.h:46
bool pass
Password mode, conceal characters.
Definition: wdata.h:58
int row
Cursor row.
Definition: wdata.h:69
int col
Cursor column.
Definition: wdata.h:70
const char * prompt
Prompt.
Definition: wdata.h:56
struct EnterState * state
Current state of text entry.
Definition: wdata.h:50
enum EnterRedrawFlags redraw
What needs redrawing? See EnterRedrawFlags.
Definition: wdata.h:57
+ 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 741 of file window.c.

742{
743 struct EnvelopeWindowData *wdata = win->wdata;
744
745 draw_envelope(win, wdata);
746 mutt_debug(LL_DEBUG5, "repaint done\n");
747 return 0;
748}
static void draw_envelope(struct MuttWindow *win, struct EnvelopeWindowData *wdata)
Write the email headers to the compose window.
Definition: window.c:668
Data to fill the Envelope Window.
Definition: wdata.h:38
+ 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.

252{
253 struct MsgWinWindowData *wdata = win->wdata;
254
255 const char *str = buf_string(wdata->text);
256 for (int i = 0; i < MSGWIN_MAX_ROWS; i++)
257 {
258 mutt_window_move(win, 0, i);
259 if (ARRAY_EMPTY(&wdata->rows[i]))
260 break;
261
262 struct MwChunk *chunk = NULL;
263 ARRAY_FOREACH(chunk, &wdata->rows[i])
264 {
266 mutt_window_addnstr(win, str + chunk->offset, chunk->bytes);
267 }
270 }
273
274 mutt_window_get_coords(win, &wdata->col, &wdata->row);
275
276 mutt_debug(LL_DEBUG5, "msgwin repaint done\n");
277 return 0;
278}
#define ARRAY_FOREACH(elem, head)
Iterate over all elements of the array.
Definition: array.h:212
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:74
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
#define MSGWIN_MAX_ROWS
Definition: msgwin_wdata.h:30
void mutt_curses_set_color(const struct AttrColor *ac)
Set the colour and attributes for text.
Definition: mutt_curses.c:38
int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
Write a partial string to a Window.
Definition: mutt_window.c:400
Message Window private Window data.
Definition: msgwin_wdata.h:66
struct Buffer * text
Cached display string.
Definition: msgwin_wdata.h:67
struct MwChunkArray rows[MSGWIN_MAX_ROWS]
String byte counts for each row.
Definition: msgwin_wdata.h:69
int row
Cursor row.
Definition: msgwin_wdata.h:70
int col
Cursor column.
Definition: msgwin_wdata.h:71
A block of characters of one colour.
Definition: msgwin_wdata.h:54
unsigned short bytes
Number of bytes in the row.
Definition: msgwin_wdata.h:56
unsigned short offset
Offset into MsgWinWindowData.text.
Definition: msgwin_wdata.h:55
const struct AttrColor * ac_color
Colour to use.
Definition: msgwin_wdata.h:58
+ 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.

96{
97 struct SBarPrivateData *priv = win->wdata;
98
99 mutt_window_move(win, 0, 0);
100
102 mutt_window_move(win, 0, 0);
103 mutt_paddstr(win, win->state.cols, priv->display);
105
106 mutt_debug(LL_DEBUG5, "repaint done\n");
107 return 0;
108}
void mutt_paddstr(struct MuttWindow *win, int n, const char *s)
Display a string on screen, padded if necessary.
Definition: curs_lib.c:341
Private data for the Simple Bar.
Definition: sbar.c:75
char * display
Cached display string.
Definition: sbar.c:76
+ 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.

180{
182 if (!wdata)
183 return 0;
184
186 mutt_window_move(win, 0, 0);
187 mutt_paddstr(win, win->state.cols, wdata->help_str);
189
190 mutt_debug(LL_DEBUG5, "repaint done\n");
191 return 0;
192}
struct HelpbarWindowData * helpbar_wdata_get(struct MuttWindow *win)
Get the Helpbar data for this window.
Definition: wdata.c:64
Help Bar Window data -.
Definition: private.h:34
+ 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 139 of file ibar.c.

140{
141 struct IBarPrivateData *ibar_data = win->wdata;
142 struct IndexSharedData *shared = ibar_data->shared;
143
144 mutt_window_move(win, 0, 0);
147
148 mutt_window_move(win, 0, 0);
149 mutt_draw_statusline(win, win->state.cols, ibar_data->status_format,
150 mutt_str_len(ibar_data->status_format));
152
153 const bool c_ts_enabled = cs_subset_bool(shared->sub, "ts_enabled");
154 if (c_ts_enabled && TsSupported)
155 {
157 mutt_ts_icon(ibar_data->ts_icon_format);
158 }
159
160 mutt_debug(LL_DEBUG5, "repaint done\n");
161 return 0;
162}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
Data to draw the Index Bar.
Definition: ibar.c:79
char * ts_icon_format
Cached terminal icon string.
Definition: ibar.c:84
struct IndexSharedData * shared
Shared Index data.
Definition: ibar.c:80
char * ts_status_format
Cached terminal status string.
Definition: ibar.c:83
char * status_format
Cached screen status string.
Definition: ibar.c:82
Data shared between Index, Pager and Sidebar.
Definition: shared_data.h:37
struct ConfigSubset * sub
Config set to use.
Definition: shared_data.h:38
bool TsSupported
Terminal Setting is supported.
Definition: terminal.c:42
void mutt_ts_icon(char *str)
Set the icon in the terminal title bar.
Definition: terminal.c:133
void mutt_ts_status(char *str)
Set the text of the terminal title bar.
Definition: terminal.c:119
+ 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 597 of file index.c.

598{
599 struct Menu *menu = win->wdata;
600
601 if (menu->redraw & MENU_REDRAW_FULL)
602 menu_redraw_full(menu);
603
604 // If we don't have the focus, then this is a mini-Index ($pager_index_lines)
605 if (!window_is_focused(menu->win))
606 {
607 int indicator = menu->page_len / 3;
608
609 /* some fudge to work out whereabouts the indicator should go */
610 const int index = menu_get_index(menu);
611 if ((index - indicator) < 0)
612 menu->top = 0;
613 else if ((menu->max - index) < (menu->page_len - indicator))
614 menu->top = menu->max - menu->page_len;
615 else
616 menu->top = index - indicator;
617 }
618 menu_adjust(menu);
620
621 struct IndexPrivateData *priv = menu->mdata;
622 struct IndexSharedData *shared = priv->shared;
623 struct Mailbox *m = shared->mailbox;
624 const int index = menu_get_index(menu);
625 if (m && m->emails && (index < m->vcount))
626 {
627 if (menu->redraw & MENU_REDRAW_INDEX)
628 {
629 menu_redraw_index(menu);
630 }
631 else if (menu->redraw & MENU_REDRAW_MOTION)
632 {
633 menu_redraw_motion(menu);
634 }
635 else if (menu->redraw & MENU_REDRAW_CURRENT)
636 {
638 }
639 }
640
642 mutt_debug(LL_DEBUG5, "repaint done\n");
643 return 0;
644}
void menu_redraw_current(struct Menu *menu)
Redraw the current menu.
Definition: draw.c:444
void menu_redraw_index(struct Menu *menu)
Force the redraw of the index.
Definition: draw.c:322
void menu_redraw_full(struct Menu *menu)
Force the redraw of the Menu.
Definition: draw.c:308
void menu_redraw_motion(struct Menu *menu)
Force the redraw of the list part of the menu.
Definition: draw.c:386
#define MENU_REDRAW_FULL
Redraw everything.
Definition: lib.h:59
void menu_adjust(struct Menu *menu)
Reapply the config to the Menu.
Definition: move.c:319
#define MENU_REDRAW_INDEX
Redraw the index.
Definition: lib.h:56
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:160
#define MENU_REDRAW_NO_FLAGS
No flags are set.
Definition: lib.h:55
#define MENU_REDRAW_CURRENT
Redraw the current line of the menu.
Definition: lib.h:58
#define MENU_REDRAW_MOTION
Redraw after moving the menu list.
Definition: lib.h:57
bool window_is_focused(const struct MuttWindow *win)
Does the given Window have the focus?
Definition: mutt_window.c:653
Private state data for the Index.
Definition: private_data.h:35
struct IndexSharedData * shared
Shared Index data.
Definition: private_data.h:40
struct Menu * menu
Menu controlling the index.
Definition: private_data.h:41
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:41
A mailbox.
Definition: mailbox.h:79
int vcount
The number of virtual messages.
Definition: mailbox.h:99
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
Definition: lib.h:79
struct MuttWindow * win
Window holding the Menu.
Definition: lib.h:86
MenuRedrawFlags redraw
When to redraw the screen.
Definition: lib.h:82
int top
Entry that is the top of the current page.
Definition: lib.h:90
void * mdata
Private data.
Definition: lib.h:147
int max
Number of entries in the menu.
Definition: lib.h:81
int page_len
Number of entries per screen.
Definition: lib.h:84
+ 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.

94{
95 if (win->type != WT_MENU)
96 return 0;
97
98 struct Menu *menu = win->wdata;
99 menu->redraw |= MENU_REDRAW_FULL;
100 menu_redraw(menu);
102
103 const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
104 const bool c_braille_friendly = cs_subset_bool(menu->sub, "braille_friendly");
105
106 /* move the cursor out of the way */
107 if (c_arrow_cursor)
108 {
109 const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
110 const int arrow_width = mutt_strwidth(c_arrow_string);
111 mutt_window_move(menu->win, arrow_width, menu->current - menu->top);
112 }
113 else if (c_braille_friendly)
114 {
115 mutt_window_move(menu->win, 0, menu->current - menu->top);
116 }
117 else
118 {
119 mutt_window_move(menu->win, menu->win->state.cols - 1, menu->current - menu->top);
120 }
121
122 mutt_debug(LL_DEBUG5, "repaint done\n");
123 return 0;
124}
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:443
int menu_redraw(struct Menu *menu)
Redraw the parts of the screen that have been flagged to be redrawn.
Definition: draw.c:479
@ WT_MENU
An Window containing a Menu.
Definition: mutt_window.h:97
int current
Current entry.
Definition: lib.h:80
struct ConfigSubset * sub
Inherited config items.
Definition: lib.h:87
enum WindowType type
Window type, e.g. WT_SIDEBAR.
Definition: mutt_window.h:143
+ 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 131 of file pager.c.

132{
133 struct PagerPrivateData *priv = win->wdata;
134 if (!priv || !priv->pview || !priv->pview->pdata)
135 return 0;
136
137 dump_pager(priv);
138
139 // We need to populate more lines, but not change position
140 const bool repopulate = (priv->cur_line > priv->lines_used);
141 if ((priv->redraw & PAGER_REDRAW_FLOW) || repopulate)
142 {
143 if (!(priv->pview->flags & MUTT_PAGER_RETWINCH))
144 {
145 priv->win_height = -1;
146 for (int i = 0; i <= priv->top_line; i++)
147 if (!priv->lines[i].cont_line)
148 priv->win_height++;
149 for (int i = 0; i < priv->lines_max; i++)
150 {
151 priv->lines[i].offset = 0;
152 priv->lines[i].cid = -1;
153 priv->lines[i].cont_line = false;
154 priv->lines[i].syntax_arr_size = 0;
155 priv->lines[i].search_arr_size = -1;
156 priv->lines[i].quote = NULL;
157
158 mutt_mem_realloc(&(priv->lines[i].syntax), sizeof(struct TextSyntax));
159 if (priv->search_compiled && priv->lines[i].search)
160 FREE(&(priv->lines[i].search));
161 }
162
163 if (!repopulate)
164 {
165 priv->lines_used = 0;
166 priv->top_line = 0;
167 }
168 }
169 int i = -1;
170 int j = -1;
171 const PagerFlags flags = priv->has_types | priv->search_flag |
172 (priv->pview->flags & MUTT_PAGER_NOWRAP) |
173 (priv->pview->flags & MUTT_PAGER_STRIPES);
174
175 while (display_line(priv->fp, &priv->bytes_read, &priv->lines, ++i,
176 &priv->lines_used, &priv->lines_max, flags, &priv->quote_list,
177 &priv->q_level, &priv->force_redraw, &priv->search_re,
178 priv->pview->win_pager, &priv->ansi_list) == 0)
179 {
180 if (!priv->lines[i].cont_line && (++j == priv->win_height))
181 {
182 if (!repopulate)
183 priv->top_line = i;
184 if (!priv->search_flag)
185 break;
186 }
187 }
188 }
189
190 if ((priv->redraw & PAGER_REDRAW_PAGER) || (priv->top_line != priv->old_top_line))
191 {
192 do
193 {
194 mutt_window_move(priv->pview->win_pager, 0, 0);
195 priv->cur_line = priv->top_line;
196 priv->old_top_line = priv->top_line;
197 priv->win_height = 0;
198 priv->force_redraw = false;
199
200 while ((priv->win_height < priv->pview->win_pager->state.rows) &&
201 (priv->lines[priv->cur_line].offset <= priv->st.st_size - 1))
202 {
203 const PagerFlags flags = (priv->pview->flags & MUTT_DISPLAYFLAGS) |
204 priv->hide_quoted | priv->search_flag |
205 (priv->pview->flags & MUTT_PAGER_NOWRAP) |
206 (priv->pview->flags & MUTT_PAGER_STRIPES);
207
208 if (display_line(priv->fp, &priv->bytes_read, &priv->lines, priv->cur_line,
209 &priv->lines_used, &priv->lines_max, flags, &priv->quote_list,
210 &priv->q_level, &priv->force_redraw, &priv->search_re,
211 priv->pview->win_pager, &priv->ansi_list) > 0)
212 {
213 priv->win_height++;
214 }
215 priv->cur_line++;
216 mutt_window_move(priv->pview->win_pager, 0, priv->win_height);
217 }
218 } while (priv->force_redraw);
219
220 const bool c_tilde = cs_subset_bool(NeoMutt->sub, "tilde");
222 while (priv->win_height < priv->pview->win_pager->state.rows)
223 {
225 if (c_tilde)
226 mutt_window_addch(priv->pview->win_pager, '~');
227 priv->win_height++;
228 mutt_window_move(priv->pview->win_pager, 0, priv->win_height);
229 }
231 }
232
234 mutt_debug(LL_DEBUG5, "repaint done\n");
235 return 0;
236}
@ MT_COLOR_TILDE
Pager: empty lines after message.
Definition: color.h:78
void dump_pager(struct PagerPrivateData *priv)
Definition: pager.c:101
int display_line(FILE *fp, LOFF_T *bytes_read, struct Line **lines, int line_num, int *lines_used, int *lines_max, PagerFlags flags, struct QuoteStyle **quote_list, int *q_level, bool *force_redraw, regex_t *search_re, struct MuttWindow *win_pager, struct AttrColorList *ansi_list)
Print a line on screen.
Definition: display.c:1042
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:115
#define FREE(x)
Definition: memory.h:45
int mutt_window_addch(struct MuttWindow *win, int ch)
Write one character to a Window.
Definition: mutt_window.c:387
#define MUTT_PAGER_RETWINCH
Need reformatting on SIGWINCH.
Definition: lib.h:71
#define MUTT_PAGER_NOWRAP
Format for term width, ignore $wrap.
Definition: lib.h:73
#define MUTT_DISPLAYFLAGS
Definition: lib.h:79
uint16_t PagerFlags
Flags for dlg_pager(), e.g. MUTT_SHOWFLAT.
Definition: lib.h:59
#define MUTT_PAGER_STRIPES
Striped highlighting.
Definition: lib.h:76
#define PAGER_REDRAW_FLOW
Reflow the pager.
Definition: lib.h:192
#define PAGER_REDRAW_PAGER
Redraw the pager.
Definition: lib.h:191
#define PAGER_REDRAW_NO_FLAGS
No flags are set.
Definition: lib.h:190
short search_arr_size
Number of items in search array.
Definition: display.h:60
struct TextSyntax * search
Array of search text in the line.
Definition: display.h:61
bool cont_line
Continuation of a previous line (wrapped by NeoMutt)
Definition: display.h:54
short cid
Default line colour, e.g. MT_COLOR_QUOTED.
Definition: display.h:53
struct QuoteStyle * quote
Quoting style for this line (pointer into PagerPrivateData->quote_list)
Definition: display.h:63
LOFF_T offset
Offset into Email file (PagerPrivateData->fp)
Definition: display.h:52
short syntax_arr_size
Number of items in syntax array.
Definition: display.h:57
struct TextSyntax * syntax
Array of coloured text in the line.
Definition: display.h:58
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
Private state data for the Pager.
Definition: private_data.h:41
PagerFlags hide_quoted
Set to MUTT_HIDE when quoted email is hidden <toggle-quoted>
Definition: private_data.h:60
int q_level
Number of unique quoting levels.
Definition: private_data.h:59
int cur_line
Current line (last line visible on screen)
Definition: private_data.h:51
int lines_used
Size of lines array (used entries)
Definition: private_data.h:49
int lines_max
Capacity of lines array (total entries)
Definition: private_data.h:50
bool force_redraw
Repaint is needed.
Definition: private_data.h:68
struct Line * lines
Array of text lines in pager.
Definition: private_data.h:48
PagerRedrawFlags redraw
When to redraw the screen.
Definition: private_data.h:69
int has_types
Set to MUTT_TYPES for PAGER_MODE_EMAIL or MUTT_SHOWCOLOR.
Definition: private_data.h:56
LOFF_T bytes_read
Number of bytes read from file.
Definition: private_data.h:46
int top_line
First visible line on screen.
Definition: private_data.h:55
struct stat st
Stats about Email file.
Definition: private_data.h:45
struct QuoteStyle * quote_list
Tree of quoting levels.
Definition: private_data.h:58
struct PagerView * pview
Object to view in the pager.
Definition: private_data.h:42
struct AttrColorList ansi_list
List of ANSI colours used in the Pager.
Definition: private_data.h:70
regex_t search_re
Compiled search string.
Definition: private_data.h:65
int win_height
Number of lines in the Window.
Definition: private_data.h:54
int old_top_line
Old top line, used for repainting.
Definition: private_data.h:53
FILE * fp
File containing decrypted/decoded/weeded Email.
Definition: private_data.h:44
PagerFlags search_flag
Set to MUTT_SEARCH when search results are visible <search-toggle>
Definition: private_data.h:62
bool search_compiled
Search regex is in use.
Definition: private_data.h:64
struct PagerData * pdata
Data that pager displays. NOTNULL.
Definition: lib.h:173
PagerFlags flags
Additional settings to tweak pager's function.
Definition: lib.h:175
struct MuttWindow * win_pager
Pager Window.
Definition: lib.h:180
Highlighting for a piece of text.
Definition: display.h:40
short rows
Number of rows, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:61
+ 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 153 of file pbar.c.

154{
155 struct PBarPrivateData *pbar_data = win->wdata;
156
157 mutt_window_move(win, 0, 0);
160
161 mutt_window_move(win, 0, 0);
162 mutt_draw_statusline(win, win->state.cols, pbar_data->pager_format,
163 mutt_str_len(pbar_data->pager_format));
165
166 mutt_debug(LL_DEBUG5, "repaint done\n");
167 return 0;
168}
Data to draw the Pager Bar.
Definition: pbar.c:83
char * pager_format
Cached status string.
Definition: pbar.c:86
+ 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 159 of file window.c.

160{
161 if (!win || !win->wdata)
162 return -1;
163
164 struct ProgressWindowData *wdata = win->wdata;
165 if (wdata->msg[0] == '\0')
166 return 0;
167
168 if (wdata->size == 0)
169 {
170 if (wdata->display_percent >= 0)
171 {
172 if (wdata->is_bytes)
173 {
174 /* L10N: Progress bar: `%s` loading text, `%s` pretty size (e.g. 4.6K),
175 `%d` is the number, `%%` is the percent symbol.
176 `%d` and `%%` may be reordered, or space inserted, if you wish. */
177 message_bar(wdata->win, wdata->display_percent, _("%s %s (%d%%)"),
178 wdata->msg, wdata->pretty_pos, wdata->display_percent);
179 }
180 else
181 {
182 /* L10N: Progress bar: `%s` loading text, `%zu` position,
183 `%d` is the number, `%%` is the percent symbol.
184 `%d` and `%%` may be reordered, or space inserted, if you wish. */
185 message_bar(wdata->win, wdata->display_percent, _("%s %zu (%d%%)"),
186 wdata->msg, wdata->display_pos, wdata->display_percent);
187 }
188 }
189 else
190 {
191 if (wdata->is_bytes)
192 {
193 /* L10N: Progress bar: `%s` loading text, `%s` position/size */
194 message_bar(wdata->win, -1, _("%s %s"), wdata->msg, wdata->pretty_pos);
195 }
196 else
197 {
198 /* L10N: Progress bar: `%s` loading text, `%zu` position */
199 message_bar(wdata->win, -1, _("%s %zu"), wdata->msg, wdata->display_pos);
200 }
201 }
202 }
203 else
204 {
205 if (wdata->is_bytes)
206 {
207 /* L10N: Progress bar: `%s` loading text, `%s/%s` position/size,
208 `%d` is the number, `%%` is the percent symbol.
209 `%d` and `%%` may be reordered, or space inserted, if you wish. */
210 message_bar(wdata->win, wdata->display_percent, _("%s %s/%s (%d%%)"),
211 wdata->msg, wdata->pretty_pos, wdata->pretty_size, wdata->display_percent);
212 }
213 else
214 {
215 /* L10N: Progress bar: `%s` loading text, `%zu/%zu` position/size,
216 `%d` is the number, `%%` is the percent symbol.
217 `%d` and `%%` may be reordered, or space inserted, if you wish. */
218 message_bar(wdata->win, wdata->display_percent, _("%s %zu/%zu (%d%%)"),
219 wdata->msg, wdata->display_pos, wdata->size, wdata->display_percent);
220 }
221 }
222
223 return 0;
224}
#define _(a)
Definition: message.h:28
static void message_bar(struct MuttWindow *win, int percent, const char *fmt,...)
Draw a colourful progress bar.
Definition: window.c:75
Progress Bar Window Data.
Definition: wdata.h:36
char msg[1024]
Message to display.
Definition: wdata.h:40
size_t size
Total expected size.
Definition: wdata.h:42
char pretty_pos[24]
Pretty string for the position.
Definition: wdata.h:51
int display_percent
Displayed percentage complete.
Definition: wdata.h:49
size_t display_pos
Displayed position.
Definition: wdata.h:48
bool is_bytes
true if measuring bytes
Definition: wdata.h:45
struct MuttWindow * win
Window to draw on.
Definition: wdata.h:37
char pretty_size[24]
Pretty string for size.
Definition: wdata.h:41
+ 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 966 of file window.c.

967{
969 const bool c_sidebar_on_right = cs_subset_bool(NeoMutt->sub, "sidebar_on_right");
970
971 int row = 0;
972 int num_rows = win->state.rows;
973 int num_cols = win->state.cols;
974
975 if (wdata->top_index >= 0)
976 {
977 int col = 0;
978 if (c_sidebar_on_right)
979 col = wdata->divider_width;
980
981 struct SbEntry **sbep = NULL;
982 ARRAY_FOREACH_FROM(sbep, &wdata->entries, wdata->top_index)
983 {
984 if (row >= num_rows)
985 break;
986
987 if ((*sbep)->is_hidden)
988 continue;
989
990 struct SbEntry *entry = (*sbep);
991 mutt_window_move(win, col, row);
993 mutt_window_printf(win, "%s", entry->display);
994 mutt_refresh();
995 row++;
996 }
997 }
998
999 fill_empty_space(win, row, num_rows - row, wdata->divider_width,
1000 num_cols - wdata->divider_width);
1001 draw_divider(wdata, win, num_rows, num_cols);
1002
1003 mutt_debug(LL_DEBUG5, "repaint done\n");
1004 return 0;
1005}
#define ARRAY_FOREACH_FROM(elem, head, from)
Iterate from an index to the end.
Definition: array.h:223
void mutt_refresh(void)
Force a refresh of the screen.
Definition: curs_lib.c:78
int mutt_window_printf(struct MuttWindow *win, const char *fmt,...)
Write a formatted string to a Window.
Definition: mutt_window.c:430
struct SidebarWindowData * sb_wdata_get(struct MuttWindow *win)
Get the Sidebar data for this window.
Definition: wdata.c:77
static void fill_empty_space(struct MuttWindow *win, int first_row, int num_rows, int div_width, int num_cols)
Wipe the remaining Sidebar space.
Definition: window.c:942
static int draw_divider(struct SidebarWindowData *wdata, struct MuttWindow *win, int num_rows, int num_cols)
Draw a line between the sidebar and the rest of neomutt.
Definition: window.c:898
Info about folders in the sidebar.
Definition: private.h:41
const struct AttrColor * color
Colour to use.
Definition: private.h:47
char display[256]
Formatted string to display.
Definition: private.h:43
Sidebar private Window data -.
Definition: private.h:88
int top_index
First mailbox visible in sidebar.
Definition: private.h:93
short divider_width
Width of the divider in screen columns.
Definition: private.h:100
struct MuttWindow * win
Sidebar Window.
Definition: private.h:89
struct SbEntryArray entries
Items to display in the sidebar.
Definition: private.h:91
+ Here is the call graph for this function:
+ Here is the caller graph for this function: