NeoMutt  2023-11-03-107-g582dc1
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 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
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 184 of file cbar.c.

185{
186 struct ComposeBarData *cbar_data = win->wdata;
187
188 mutt_window_move(win, 0, 0);
191
192 mutt_window_move(win, 0, 0);
193 mutt_draw_statusline(win, win->state.cols, cbar_data->compose_format,
194 mutt_str_len(cbar_data->compose_format));
196 mutt_debug(LL_DEBUG5, "repaint done\n");
197
198 return 0;
199}
@ MT_COLOR_STATUS
Status bar (takes a pattern)
Definition: color.h:74
@ MT_COLOR_NORMAL
Plain text.
Definition: color.h:58
void mutt_draw_statusline(struct MuttWindow *win, int cols, const char *buf, size_t buflen)
Draw a highlighted status bar.
Definition: dlg_index.c:917
#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:568
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:65
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:81
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:297
void mutt_window_clrtoeol(struct MuttWindow *win)
Clear to the end of the line.
Definition: mutt_window.c:244
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:127
void * wdata
Private data.
Definition: mutt_window.h:145
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 187 of file window.c.

188{
189 if (!mutt_window_is_visible(win))
190 return 0;
191
192 struct EnterWindowData *wdata = win->wdata;
193
194 mutt_window_clearline(win, 0);
196 mutt_window_addstr(win, wdata->prompt);
198
199 int prompt_length = 0;
200 mutt_window_get_coords(win, &prompt_length, NULL);
201
202 int width = win->state.cols - prompt_length - 1;
203
204 if (!wdata->pass)
205 {
206 if (wdata->redraw == ENTER_REDRAW_INIT)
207 {
208 /* Go to end of line */
209 wdata->state->curpos = wdata->state->lastchar;
211 wdata->state->wbuf, wdata->state->lastchar,
212 mutt_mb_wcswidth(wdata->state->wbuf, wdata->state->lastchar) - width + 1);
213 }
214 if ((wdata->state->curpos < wdata->state->begin) ||
215 (mutt_mb_wcswidth(wdata->state->wbuf + wdata->state->begin,
216 wdata->state->curpos - wdata->state->begin) >= width))
217 {
219 wdata->state->wbuf, wdata->state->lastchar,
220 mutt_mb_wcswidth(wdata->state->wbuf, wdata->state->curpos) - (width / 2));
221 }
222 mutt_window_move(win, prompt_length, 0);
223 int w = 0;
224 for (size_t i = wdata->state->begin; i < wdata->state->lastchar; i++)
225 {
226 w += mutt_mb_wcwidth(wdata->state->wbuf[i]);
227 if (w > width)
228 break;
229 my_addwch(win, wdata->state->wbuf[i]);
230 }
233 prompt_length +
234 mutt_mb_wcswidth(wdata->state->wbuf + wdata->state->begin,
235 wdata->state->curpos - wdata->state->begin),
236 0);
237 }
238
239 mutt_window_get_coords(win, &wdata->col, &wdata->row);
240 mutt_debug(LL_DEBUG5, "repaint done\n");
241
242 return 0;
243}
@ MT_COLOR_PROMPT
Question/user input.
Definition: color.h:61
@ 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:72
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:236
int mutt_mb_wcswidth(const wchar_t *s, size_t n)
Measure the screen width of a string.
Definition: mbyte.c:215
int mutt_mb_wcwidth(wchar_t wc)
Measure the screen width of a character.
Definition: mbyte.c:197
bool mutt_window_is_visible(struct MuttWindow *win)
Is the Window visible?
Definition: mutt_window.c:512
void mutt_window_get_coords(struct MuttWindow *win, int *col, int *row)
Get the cursor position in the Window.
Definition: mutt_window.c:277
void mutt_window_clearline(struct MuttWindow *win, int row)
Clear a row of a Window.
Definition: mutt_window.c:232
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition: mutt_window.c:416
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 790 of file window.c.

791{
792 struct EnvelopeWindowData *wdata = win->wdata;
793
794 draw_envelope(win, wdata);
795 mutt_debug(LL_DEBUG5, "repaint done\n");
796 return 0;
797}
static void draw_envelope(struct MuttWindow *win, struct EnvelopeWindowData *wdata)
Write the email headers to the compose window.
Definition: window.c:714
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:211
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:73
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:93
#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:40
int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
Write a partial string to a Window.
Definition: mutt_window.c:401
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:352
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 138 of file ibar.c.

139{
140 struct IBarPrivateData *ibar_data = win->wdata;
141 struct IndexSharedData *shared = ibar_data->shared;
142
143 mutt_window_move(win, 0, 0);
146
147 mutt_window_move(win, 0, 0);
148 mutt_draw_statusline(win, win->state.cols, ibar_data->status_format,
149 mutt_str_len(ibar_data->status_format));
151
152 const bool c_ts_enabled = cs_subset_bool(shared->sub, "ts_enabled");
153 if (c_ts_enabled && TsSupported)
154 {
156 mutt_ts_icon(ibar_data->ts_icon_format);
157 }
158
159 mutt_debug(LL_DEBUG5, "repaint done\n");
160 return 0;
161}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
Data to draw the Index Bar.
Definition: ibar.c:78
char * ts_icon_format
Cached terminal icon string.
Definition: ibar.c:83
struct IndexSharedData * shared
Shared Index data.
Definition: ibar.c:79
char * ts_status_format
Cached terminal status string.
Definition: ibar.c:82
char * status_format
Cached screen status string.
Definition: ibar.c:81
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:41
void mutt_ts_icon(char *str)
Set the icon in the terminal title bar.
Definition: terminal.c:116
void mutt_ts_status(char *str)
Set the text of the terminal title bar.
Definition: terminal.c:102
+ 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.

545{
546 struct Menu *menu = win->wdata;
547
548 if (menu->redraw & MENU_REDRAW_FULL)
549 menu_redraw_full(menu);
550
551 // If we don't have the focus, then this is a mini-Index ($pager_index_lines)
552 if (!window_is_focused(menu->win))
553 {
554 int indicator = menu->page_len / 3;
555
556 /* some fudge to work out whereabouts the indicator should go */
557 const int index = menu_get_index(menu);
558 if ((index - indicator) < 0)
559 menu->top = 0;
560 else if ((menu->max - index) < (menu->page_len - indicator))
561 menu->top = menu->max - menu->page_len;
562 else
563 menu->top = index - indicator;
564 }
565 menu_adjust(menu);
567
568 struct IndexPrivateData *priv = menu->mdata;
569 struct IndexSharedData *shared = priv->shared;
570 struct Mailbox *m = shared->mailbox;
571 const int index = menu_get_index(menu);
572 if (m && m->emails && (index < m->vcount))
573 {
574 if (menu->redraw & MENU_REDRAW_INDEX)
575 {
576 menu_redraw_index(menu);
577 }
578 else if (menu->redraw & MENU_REDRAW_MOTION)
579 {
580 menu_redraw_motion(menu);
581 }
582 else if (menu->redraw & MENU_REDRAW_CURRENT)
583 {
585 }
586 }
587
589 mutt_debug(LL_DEBUG5, "repaint done\n");
590 return 0;
591}
void menu_redraw_current(struct Menu *menu)
Redraw the current menu.
Definition: draw.c:438
void menu_redraw_index(struct Menu *menu)
Force the redraw of the index.
Definition: draw.c:321
void menu_redraw_full(struct Menu *menu)
Force the redraw of the Menu.
Definition: draw.c:307
void menu_redraw_motion(struct Menu *menu)
Force the redraw of the list part of the menu.
Definition: draw.c:379
#define MENU_REDRAW_FULL
Redraw everything.
Definition: lib.h:60
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:57
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:156
#define MENU_REDRAW_NO_FLAGS
No flags are set.
Definition: lib.h:56
#define MENU_REDRAW_CURRENT
Redraw the current line of the menu.
Definition: lib.h:59
#define MENU_REDRAW_MOTION
Redraw after moving the menu list.
Definition: lib.h:58
bool window_is_focused(const struct MuttWindow *win)
Does the given Window have the focus?
Definition: mutt_window.c:654
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:70
struct MuttWindow * win
Window holding the Menu.
Definition: lib.h:77
MenuRedrawFlags redraw
When to redraw the screen.
Definition: lib.h:73
int top
Entry that is the top of the current page.
Definition: lib.h:81
void * mdata
Private data.
Definition: lib.h:137
int max
Number of entries in the menu.
Definition: lib.h:72
int page_len
Number of entries per screen.
Definition: lib.h:75
+ 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:292
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:454
int menu_redraw(struct Menu *menu)
Redraw the parts of the screen that have been flagged to be redrawn.
Definition: draw.c:474
@ WT_MENU
An Window containing a Menu.
Definition: mutt_window.h:98
int current
Current entry.
Definition: lib.h:71
struct ConfigSubset * sub
Inherited config items.
Definition: lib.h:78
enum WindowType type
Window type, e.g. WT_SIDEBAR.
Definition: mutt_window.h:144
+ 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.

146{
147 for (int i = 0; i < win->state.rows; i++)
148 {
149 mutt_window_move(win, 0, i);
151 }
152
153 struct ChainData *cd = win->wdata;
154
155 if (cd->chain_len == 0)
156 return 0;
157
158 for (int i = 0; i < cd->chain_len; i++)
159 {
160 if (cd->coords[i].row < win->state.rows)
161 {
162 if (i == cd->sel)
164 else
166
167 int index = cd->chain[i];
168 struct Remailer **rp = ARRAY_GET(cd->ra, index);
169 mutt_window_mvaddstr(win, cd->coords[i].col, cd->coords[i].row, (*rp)->shortname);
171
172 if ((i + 1) < cd->chain_len)
173 mutt_window_addstr(win, ", ");
174 }
175 }
176 return 0;
177}
#define ARRAY_GET(head, idx)
Return the element at index.
Definition: array.h:108
@ MT_COLOR_INDICATOR
Selected item in list.
Definition: color.h:53
int mutt_window_mvaddstr(struct MuttWindow *win, int col, int row, const char *str)
Move the cursor and write a fixed string to a Window.
Definition: mutt_window.c:311
An ordered set of Remailer hosts.
Definition: chain_data.h:46
int chain_len
Length of chain.
Definition: chain_data.h:48
struct RemailerArray * ra
Array of all Remailer hosts.
Definition: chain_data.h:51
int chain[MAX_MIXES]
Indexes of chain hosts.
Definition: chain_data.h:49
int sel
Current selection.
Definition: chain_data.h:47
struct Coord coords[MAX_MIXES]
Screen coordinates of each entry.
Definition: chain_data.h:50
short col
Column.
Definition: chain_data.h:37
short row
Row.
Definition: chain_data.h:36
A Mixmaster remailer.
Definition: remailer.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:

◆ 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.

130{
131 struct PagerPrivateData *priv = win->wdata;
132 if (!priv || !priv->pview || !priv->pview->pdata)
133 return 0;
134
135 dump_pager(priv);
136
137 // We need to populate more lines, but not change position
138 const bool repopulate = (priv->cur_line > priv->lines_used);
139 if ((priv->redraw & PAGER_REDRAW_FLOW) || repopulate)
140 {
141 if (!(priv->pview->flags & MUTT_PAGER_RETWINCH))
142 {
143 priv->win_height = -1;
144 for (int i = 0; i <= priv->top_line; i++)
145 if (!priv->lines[i].cont_line)
146 priv->win_height++;
147 for (int i = 0; i < priv->lines_max; i++)
148 {
149 priv->lines[i].offset = 0;
150 priv->lines[i].cid = -1;
151 priv->lines[i].cont_line = false;
152 priv->lines[i].syntax_arr_size = 0;
153 priv->lines[i].search_arr_size = -1;
154 priv->lines[i].quote = NULL;
155
156 mutt_mem_realloc(&(priv->lines[i].syntax), sizeof(struct TextSyntax));
157 if (priv->search_compiled && priv->lines[i].search)
158 FREE(&(priv->lines[i].search));
159 }
160
161 if (!repopulate)
162 {
163 priv->lines_used = 0;
164 priv->top_line = 0;
165 }
166 }
167 int i = -1;
168 int j = -1;
169 const PagerFlags flags = priv->has_types | priv->search_flag |
170 (priv->pview->flags & MUTT_PAGER_NOWRAP) |
171 (priv->pview->flags & MUTT_PAGER_STRIPES);
172
173 while (display_line(priv->fp, &priv->bytes_read, &priv->lines, ++i,
174 &priv->lines_used, &priv->lines_max, flags, &priv->quote_list,
175 &priv->q_level, &priv->force_redraw, &priv->search_re,
176 priv->pview->win_pager, &priv->ansi_list) == 0)
177 {
178 if (!priv->lines[i].cont_line && (++j == priv->win_height))
179 {
180 if (!repopulate)
181 priv->top_line = i;
182 if (!priv->search_flag)
183 break;
184 }
185 }
186 }
187
188 if ((priv->redraw & PAGER_REDRAW_PAGER) || (priv->top_line != priv->old_top_line))
189 {
190 do
191 {
192 mutt_window_move(priv->pview->win_pager, 0, 0);
193 priv->cur_line = priv->top_line;
194 priv->old_top_line = priv->top_line;
195 priv->win_height = 0;
196 priv->force_redraw = false;
197
198 while ((priv->win_height < priv->pview->win_pager->state.rows) &&
199 (priv->lines[priv->cur_line].offset <= priv->st.st_size - 1))
200 {
201 const PagerFlags flags = (priv->pview->flags & MUTT_DISPLAYFLAGS) |
202 priv->hide_quoted | priv->search_flag |
203 (priv->pview->flags & MUTT_PAGER_NOWRAP) |
204 (priv->pview->flags & MUTT_PAGER_STRIPES);
205
206 if (display_line(priv->fp, &priv->bytes_read, &priv->lines, priv->cur_line,
207 &priv->lines_used, &priv->lines_max, flags, &priv->quote_list,
208 &priv->q_level, &priv->force_redraw, &priv->search_re,
209 priv->pview->win_pager, &priv->ansi_list) > 0)
210 {
211 priv->win_height++;
212 }
213 priv->cur_line++;
214 mutt_window_move(priv->pview->win_pager, 0, priv->win_height);
215 }
216 } while (priv->force_redraw);
217
218 const bool c_tilde = cs_subset_bool(NeoMutt->sub, "tilde");
220 while (priv->win_height < priv->pview->win_pager->state.rows)
221 {
223 if (c_tilde)
224 mutt_window_addch(priv->pview->win_pager, '~');
225 priv->win_height++;
226 mutt_window_move(priv->pview->win_pager, 0, priv->win_height);
227 }
229 }
230
232 mutt_debug(LL_DEBUG5, "repaint done\n");
233 return 0;
234}
@ MT_COLOR_TILDE
Pager: empty lines after message.
Definition: color.h:77
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:1018
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:114
#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:388
#define MUTT_PAGER_RETWINCH
Need reformatting on SIGWINCH.
Definition: lib.h:70
#define MUTT_PAGER_NOWRAP
Format for term width, ignore $wrap.
Definition: lib.h:72
#define MUTT_DISPLAYFLAGS
Definition: lib.h:78
uint16_t PagerFlags
Flags for dlg_pager(), e.g. MUTT_SHOWFLAT.
Definition: lib.h:58
#define MUTT_PAGER_STRIPES
Striped highlighting.
Definition: lib.h:75
#define PAGER_REDRAW_FLOW
Reflow the pager.
Definition: lib.h:191
#define PAGER_REDRAW_PAGER
Redraw the pager.
Definition: lib.h:190
#define PAGER_REDRAW_NO_FLAGS
No flags are set.
Definition: lib.h:189
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:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
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:172
PagerFlags flags
Additional settings to tweak pager's function.
Definition: lib.h:174
struct MuttWindow * win_pager
Pager Window.
Definition: lib.h:179
Highlighting for a piece of text.
Definition: display.h:40
+ 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.

155{
156 struct PBarPrivateData *pbar_data = win->wdata;
157
158 mutt_window_move(win, 0, 0);
161
162 mutt_window_move(win, 0, 0);
163 mutt_draw_statusline(win, win->state.cols, pbar_data->pager_format,
164 mutt_str_len(pbar_data->pager_format));
166
167 mutt_debug(LL_DEBUG5, "repaint done\n");
168 return 0;
169}
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 157 of file window.c.

158{
159 if (!win || !win->wdata)
160 return -1;
161
162 struct ProgressWindowData *wdata = win->wdata;
163 if (wdata->msg[0] == '\0')
164 return 0;
165
166 if (wdata->size == 0)
167 {
168 if (wdata->display_percent >= 0)
169 {
170 if (wdata->is_bytes)
171 {
172 /* L10N: Progress bar: `%s` loading text, `%s` pretty size (e.g. 4.6K),
173 `%d` is the number, `%%` is the percent symbol.
174 `%d` and `%%` may be reordered, or space inserted, if you wish. */
175 message_bar(wdata->win, wdata->display_percent, _("%s %s (%d%%)"),
176 wdata->msg, wdata->pretty_pos, wdata->display_percent);
177 }
178 else
179 {
180 /* L10N: Progress bar: `%s` loading text, `%zu` position,
181 `%d` is the number, `%%` is the percent symbol.
182 `%d` and `%%` may be reordered, or space inserted, if you wish. */
183 message_bar(wdata->win, wdata->display_percent, _("%s %zu (%d%%)"),
184 wdata->msg, wdata->display_pos, wdata->display_percent);
185 }
186 }
187 else
188 {
189 if (wdata->is_bytes)
190 {
191 /* L10N: Progress bar: `%s` loading text, `%s` position/size */
192 message_bar(wdata->win, -1, _("%s %s"), wdata->msg, wdata->pretty_pos);
193 }
194 else
195 {
196 /* L10N: Progress bar: `%s` loading text, `%zu` position */
197 message_bar(wdata->win, -1, _("%s %zu"), wdata->msg, wdata->display_pos);
198 }
199 }
200 }
201 else
202 {
203 if (wdata->is_bytes)
204 {
205 /* L10N: Progress bar: `%s` loading text, `%s/%s` position/size,
206 `%d` is the number, `%%` is the percent symbol.
207 `%d` and `%%` may be reordered, or space inserted, if you wish. */
208 message_bar(wdata->win, wdata->display_percent, _("%s %s/%s (%d%%)"),
209 wdata->msg, wdata->pretty_pos, wdata->pretty_size, wdata->display_percent);
210 }
211 else
212 {
213 /* L10N: Progress bar: `%s` loading text, `%zu/%zu` position/size,
214 `%d` is the number, `%%` is the percent symbol.
215 `%d` and `%%` may be reordered, or space inserted, if you wish. */
216 message_bar(wdata->win, wdata->display_percent, _("%s %zu/%zu (%d%%)"),
217 wdata->msg, wdata->display_pos, wdata->size, wdata->display_percent);
218 }
219 }
220
221 return 0;
222}
#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:74
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 959 of file window.c.

960{
962 const bool c_sidebar_on_right = cs_subset_bool(NeoMutt->sub, "sidebar_on_right");
963
964 int row = 0;
965 int num_rows = win->state.rows;
966 int num_cols = win->state.cols;
967
968 if (wdata->top_index >= 0)
969 {
970 int col = 0;
971 if (c_sidebar_on_right)
972 col = wdata->divider_width;
973
974 struct SbEntry **sbep = NULL;
975 ARRAY_FOREACH_FROM(sbep, &wdata->entries, wdata->top_index)
976 {
977 if (row >= num_rows)
978 break;
979
980 if ((*sbep)->is_hidden)
981 continue;
982
983 struct SbEntry *entry = (*sbep);
984 mutt_window_move(win, col, row);
986 mutt_window_printf(win, "%s", entry->display);
987 mutt_refresh();
988 row++;
989 }
990 }
991
992 fill_empty_space(win, row, num_rows - row, wdata->divider_width,
993 num_cols - wdata->divider_width);
994 draw_divider(wdata, win, num_rows, num_cols);
995
996 mutt_debug(LL_DEBUG5, "repaint done\n");
997 return 0;
998}
#define ARRAY_FOREACH_FROM(elem, head, from)
Iterate from an index to the end.
Definition: array.h:222
void mutt_refresh(void)
Force a refresh of the screen.
Definition: curs_lib.c:75
int mutt_window_printf(struct MuttWindow *win, const char *fmt,...)
Write a formatted string to a Window.
Definition: mutt_window.c:431
struct SidebarWindowData * sb_wdata_get(struct MuttWindow *win)
Get the Sidebar data for this window.
Definition: wdata.c:76
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:935
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:891
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:64
int top_index
First mailbox visible in sidebar.
Definition: private.h:69
short divider_width
Width of the divider in screen columns.
Definition: private.h:76
struct MuttWindow * win
Sidebar Window.
Definition: private.h:65
struct SbEntryArray entries
Items to display in the sidebar.
Definition: private.h:67
+ Here is the call graph for this function:
+ Here is the caller graph for this function: