NeoMutt  2025-12-11-1039-g550ac6
Teaching an old dog new tricks
 		DOXYGEN
Loading...
Searching...
No Matches
draw.c
Go to the documentation of this file.
1
23
29
30#include "config.h"
31#include <stdbool.h>
32#include <string.h>
33#include <wchar.h>
34#include "mutt/lib.h"
35#include "config/lib.h"
36#include "email/lib.h"
37#include "core/lib.h"
38#include "gui/lib.h"
39#include "lib.h"
40#include "color/lib.h"
41#include "index/lib.h"
42#include "pattern/lib.h"
43
53static const struct AttrColor *get_color(int index, unsigned char *s)
54{
55 const int type = *s;
56 struct RegexColorList *rcl = regex_colors_get_list(type);
57 struct Mailbox *m_cur = get_current_mailbox();
58 struct Email *e = mutt_get_virt_email(m_cur, index);
59 if (!rcl || !e)
60 {
61 return simple_color_get(type);
62 }
63
64 struct RegexColor *np = NULL;
65 const struct AttrColor *ac_merge = NULL;
66
67 struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
68 ASSERT(mod_data);
69
70 struct Buffer *buf = buf_pool_get();
71 buf_strcpy(buf, (const char *) (s + 1));
72 char *marker = (char *) buf_find_char(buf, MUTT_SPECIAL_INDEX);
73 if (marker)
74 *marker = '\0';
75
76 // %Gx %{tags-transformed} - Transformed message tags
77 if (type == MT_COLOR_INDEX_TAG)
78 {
79 STAILQ_FOREACH(np, rcl, entries)
80 {
81 const char *transform = mutt_hash_find(mod_data->tag_transforms, np->pattern);
82 if (transform && strstr(buf_string(buf), transform))
83
84 {
85 ac_merge = merged_color_overlay(ac_merge, &np->attr_color);
86 }
87 }
88 goto done;
89 }
90
91 STAILQ_FOREACH(np, rcl, entries)
92 {
93 if (mutt_pattern_exec(SLIST_FIRST(np->color_pattern),
94 MUTT_MATCH_FULL_ADDRESS, m_cur, e, NULL))
95 {
96 ac_merge = merged_color_overlay(ac_merge, &np->attr_color);
97 }
98 }
99
100done:
101 buf_pool_release(&buf);
102 return ac_merge;
103}
104
114static void print_enriched_string(struct MuttWindow *win, int index,
115 const struct AttrColor *ac_def, struct AttrColor *ac_ind,
116 struct Buffer *buf, struct ConfigSubset *sub)
117{
118 wchar_t wc = 0;
119 size_t k;
120 size_t n = mutt_str_len(buf_string(buf));
121 unsigned char *s = (unsigned char *) buf->data;
122 mbstate_t mbstate = { 0 };
123
124 const bool c_ascii_chars = cs_subset_bool(sub, "ascii_chars");
125 while (*s)
126 {
127 if (*s < MUTT_TREE_MAX)
128 {
129 /* Combining tree fg color and another bg color requires having
130 * use_default_colors, because the other bg color may be undefined. */
131 mutt_curses_set_color(ac_ind);
132
133 while (*s && (*s < MUTT_TREE_MAX))
134 {
135 switch (*s)
136 {
137 case MUTT_TREE_LLCORNER:
138 if (c_ascii_chars)
139 mutt_window_addch(win, '`');
140#ifdef WACS_LLCORNER
141 else
142 add_wch(WACS_LLCORNER);
143#else
144 else if (CharsetIsUtf8)
145 mutt_window_addstr(win, "\342\224\224"); /* WACS_LLCORNER */
146 else
147 mutt_window_addch(win, ACS_LLCORNER);
148#endif
149 break;
150 case MUTT_TREE_ULCORNER:
151 if (c_ascii_chars)
152 mutt_window_addch(win, ',');
153#ifdef WACS_ULCORNER
154 else
155 add_wch(WACS_ULCORNER);
156#else
157 else if (CharsetIsUtf8)
158 mutt_window_addstr(win, "\342\224\214"); /* WACS_ULCORNER */
159 else
160 mutt_window_addch(win, ACS_ULCORNER);
161#endif
162 break;
163 case MUTT_TREE_LTEE:
164 if (c_ascii_chars)
165 mutt_window_addch(win, '|');
166#ifdef WACS_LTEE
167 else
168 add_wch(WACS_LTEE);
169#else
170 else if (CharsetIsUtf8)
171 mutt_window_addstr(win, "\342\224\234"); /* WACS_LTEE */
172 else
173 mutt_window_addch(win, ACS_LTEE);
174#endif
175 break;
176 case MUTT_TREE_HLINE:
177 if (c_ascii_chars)
178 mutt_window_addch(win, '-');
179#ifdef WACS_HLINE
180 else
181 add_wch(WACS_HLINE);
182#else
183 else if (CharsetIsUtf8)
184 mutt_window_addstr(win, "\342\224\200"); /* WACS_HLINE */
185 else
186 mutt_window_addch(win, ACS_HLINE);
187#endif
188 break;
189 case MUTT_TREE_VLINE:
190 if (c_ascii_chars)
191 mutt_window_addch(win, '|');
192#ifdef WACS_VLINE
193 else
194 add_wch(WACS_VLINE);
195#else
196 else if (CharsetIsUtf8)
197 mutt_window_addstr(win, "\342\224\202"); /* WACS_VLINE */
198 else
199 mutt_window_addch(win, ACS_VLINE);
200#endif
201 break;
202 case MUTT_TREE_TTEE:
203 if (c_ascii_chars)
204 mutt_window_addch(win, '-');
205#ifdef WACS_TTEE
206 else
207 add_wch(WACS_TTEE);
208#else
209 else if (CharsetIsUtf8)
210 mutt_window_addstr(win, "\342\224\254"); /* WACS_TTEE */
211 else
212 mutt_window_addch(win, ACS_TTEE);
213#endif
214 break;
215 case MUTT_TREE_BTEE:
216 if (c_ascii_chars)
217 mutt_window_addch(win, '-');
218#ifdef WACS_BTEE
219 else
220 add_wch(WACS_BTEE);
221#else
222 else if (CharsetIsUtf8)
223 mutt_window_addstr(win, "\342\224\264"); /* WACS_BTEE */
224 else
225 mutt_window_addch(win, ACS_BTEE);
226#endif
227 break;
228 case MUTT_TREE_SPACE:
229 mutt_window_addch(win, ' ');
230 break;
231 case MUTT_TREE_RARROW:
232 mutt_window_addch(win, '>');
233 break;
234 case MUTT_TREE_STAR:
235 mutt_window_addch(win, '*'); /* fake thread indicator */
236 break;
237 case MUTT_TREE_HIDDEN:
238 mutt_window_addch(win, '&');
239 break;
240 case MUTT_TREE_EQUALS:
241 mutt_window_addch(win, '=');
242 break;
243 case MUTT_TREE_MISSING:
244 mutt_window_addch(win, '?');
245 break;
246 default:
247 break;
248 }
249 s++;
250 n--;
251 }
252 const struct AttrColor *ac_merge = merged_color_overlay(ac_def, ac_ind);
253 mutt_curses_set_color(ac_merge);
254 }
255 else if ((*s == MUTT_SPECIAL_INDEX) && (n >= 2))
256 {
257 s++;
258 if (*s == MT_COLOR_INDEX)
259 {
260 const struct AttrColor *ac_merge = merged_color_overlay(ac_def, ac_ind);
261 mutt_curses_set_color(ac_merge);
262 }
263 else
264 {
265 const struct AttrColor *color = get_color(index, s);
266 const struct AttrColor *ac_merge = merged_color_overlay(ac_def, color);
267 ac_merge = merged_color_overlay(ac_merge, ac_ind);
268
269 mutt_curses_set_color(ac_merge);
270 }
271 s++;
272 n -= 2;
273 }
274 else if ((k = mbrtowc(&wc, (char *) s, n, &mbstate)) > 0)
275 {
276 mutt_window_addnstr(win, (char *) s, k);
277 s += k;
278 n -= k;
279 }
280 else
281 {
282 break;
283 }
284 }
285}
286
294static void menu_pad_string(struct Menu *menu, struct Buffer *buf)
295{
296 int max_cols = menu->win->state.cols;
297 const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
298 if (c_arrow_cursor)
299 {
300 const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
301 if (max_cols > 0)
302 max_cols -= (mutt_strwidth(c_arrow_string) + 1);
303 }
304
305 int buf_cols = mutt_strwidth(buf_string(buf));
306 for (; buf_cols < max_cols; buf_cols++)
307 {
308 buf_addch(buf, ' ');
309 }
310}
311
316void menu_redraw_full(struct Menu *menu)
317{
318 mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
319 mutt_window_clear(menu->win);
320
321 menu->page_len = menu->win->state.rows;
322
323 menu->redraw = MENU_REDRAW_INDEX;
324}
325
330void menu_redraw_index(struct Menu *menu)
331{
332 struct Buffer *buf = buf_pool_get();
333 const struct AttrColor *ac = NULL;
334
335 const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
336 const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
337 const int arrow_width = mutt_strwidth(c_arrow_string);
338 struct AttrColor *ac_ind = menu->show_indicator ? simple_color_get(MT_COLOR_INDICATOR) : NULL;
339 for (int i = menu->top; i < (menu->top + menu->page_len); i++)
340 {
341 if (i < menu->max)
342 {
343 ac = menu->color(menu, i);
344
345 buf_reset(buf);
346 menu->make_entry(menu, i, menu->win->state.cols, buf);
347 menu_pad_string(menu, buf);
348
349 mutt_curses_set_color(ac);
350 mutt_window_move(menu->win, i - menu->top, 0);
351
352 if (i == menu->current)
353 mutt_curses_set_color(ac_ind);
354
355 if (c_arrow_cursor)
356 {
357 if (i == menu->current)
358 {
359 mutt_window_addstr(menu->win, c_arrow_string);
360 mutt_curses_set_color(ac);
361 mutt_window_addch(menu->win, ' ');
362 }
363 else
364 {
365 /* Print space chars to match the screen width of `$arrow_string` */
366 mutt_window_printf(menu->win, "%*s", arrow_width + 1, "");
367 }
368 }
369
370 if ((i == menu->current) && !c_arrow_cursor)
371 {
372 print_enriched_string(menu->win, i, ac, ac_ind, buf, menu->sub);
373 }
374 else
375 {
376 print_enriched_string(menu->win, i, ac, NULL, buf, menu->sub);
377 }
378 }
379 else
380 {
381 mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
382 mutt_window_clearline(menu->win, i - menu->top);
383 }
384 }
385 mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
386 menu->redraw = MENU_REDRAW_NONE;
387 buf_pool_release(&buf);
388}
389
394void menu_redraw_motion(struct Menu *menu)
395{
396 struct Buffer *buf = buf_pool_get();
397
398 /* Note: menu->color() for the index can end up retrieving a message
399 * over imap (if matching against ~h for instance). This can
400 * generate status messages. So we want to call it *before* we
401 * position the cursor for drawing. */
402 const struct AttrColor *old_color = menu->color(menu, menu->old_current);
403 mutt_window_move(menu->win, menu->old_current - menu->top, 0);
404 mutt_curses_set_color(old_color);
405
406 const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
407 struct AttrColor *ac_ind = menu->show_indicator ? simple_color_get(MT_COLOR_INDICATOR) : NULL;
408 if (c_arrow_cursor)
409 {
410 const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
411 const int arrow_width = mutt_strwidth(c_arrow_string);
412 /* clear the arrow */
413 /* Print space chars to match the screen width of `$arrow_string` */
414 mutt_window_printf(menu->win, "%*s", arrow_width + 1, "");
415 mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
416
417 menu->make_entry(menu, menu->old_current, menu->win->state.cols, buf);
418 menu_pad_string(menu, buf);
419 mutt_window_move(menu->win, menu->old_current - menu->top, arrow_width + 1);
420 print_enriched_string(menu->win, menu->old_current, old_color, NULL, buf, menu->sub);
421
422 /* now draw it in the new location */
423 mutt_curses_set_color(ac_ind);
424 mutt_window_move(menu->win, menu->current - menu->top, 0);
425 mutt_window_addstr(menu->win, c_arrow_string);
426 }
427 else
428 {
429 mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
430 /* erase the current indicator */
431 menu->make_entry(menu, menu->old_current, menu->win->state.cols, buf);
432 menu_pad_string(menu, buf);
433 print_enriched_string(menu->win, menu->old_current, old_color, NULL, buf, menu->sub);
434
435 /* now draw the new one to reflect the change */
436 const struct AttrColor *cur_color = menu->color(menu, menu->current);
437 cur_color = merged_color_overlay(cur_color, ac_ind);
438 buf_reset(buf);
439 menu->make_entry(menu, menu->current, menu->win->state.cols, buf);
440 menu_pad_string(menu, buf);
441 mutt_window_move(menu->win, menu->current - menu->top, 0);
442 mutt_curses_set_color(cur_color);
443 print_enriched_string(menu->win, menu->current, cur_color, ac_ind, buf, menu->sub);
444 }
445 mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
446 buf_pool_release(&buf);
447}
448
453void menu_redraw_current(struct Menu *menu)
454{
455 struct Buffer *buf = buf_pool_get();
456 const struct AttrColor *ac = menu->color(menu, menu->current);
457
458 mutt_window_move(menu->win, menu->current - menu->top, 0);
459 menu->make_entry(menu, menu->current, menu->win->state.cols, buf);
460 menu_pad_string(menu, buf);
461
462 struct AttrColor *ac_ind = menu->show_indicator ? simple_color_get(MT_COLOR_INDICATOR) : NULL;
463 const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
464 if (c_arrow_cursor)
465 {
466 mutt_curses_set_color(ac_ind);
467 const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
468 mutt_window_addstr(menu->win, c_arrow_string);
469 mutt_curses_set_color(ac);
470 mutt_window_addch(menu->win, ' ');
471 menu_pad_string(menu, buf);
472 print_enriched_string(menu->win, menu->current, ac, NULL, buf, menu->sub);
473 }
474 else
475 {
476 print_enriched_string(menu->win, menu->current, ac, ac_ind, buf, menu->sub);
477 }
478 mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
479 buf_pool_release(&buf);
480}
481
488int menu_redraw(struct Menu *menu)
489{
490 /* See if all or part of the screen needs to be updated. */
491 if (menu->redraw & MENU_REDRAW_FULL)
492 menu_redraw_full(menu);
493
494 if (menu->redraw & MENU_REDRAW_INDEX)
495 menu_redraw_index(menu);
496 else if (menu->redraw & MENU_REDRAW_MOTION)
497 menu_redraw_motion(menu);
498 else if (menu->redraw == MENU_REDRAW_CURRENT)
499 menu_redraw_current(menu);
500
501 return OP_NULL;
502}
buf_reset
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition buffer.c:89
buf_addch
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition buffer.c:248
buf_find_char
const char * buf_find_char(const struct Buffer *buf, const char c)
Return a pointer to a char found in the buffer.
Definition buffer.c:659
buf_strcpy
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition buffer.c:401
buf_string
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition buffer.h:96
lib.h
Color and attribute parsing.
regex_colors_get_list
struct RegexColorList * regex_colors_get_list(enum ColorId cid)
Return the RegexColorList for a Colour ID.
Definition regex.c:192
simple_color_get
struct AttrColor * simple_color_get(enum ColorId cid)
Get the colour of an object by its ID.
Definition simple.c:98
MT_COLOR_INDICATOR
@ MT_COLOR_INDICATOR
Selected item in list.
Definition color.h:49
MT_COLOR_INDEX_TAG
@ MT_COLOR_INDEX_TAG
Index: tag field (G).
Definition color.h:95
MT_COLOR_NORMAL
@ MT_COLOR_NORMAL
Plain text.
Definition color.h:53
MT_COLOR_INDEX
@ MT_COLOR_INDEX
Index: default colour.
Definition color.h:86
cs_subset_string
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition helpers.c:291
cs_subset_bool
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition helpers.c:47
lib.h
Convenience wrapper for the config headers.
lib.h
Convenience wrapper for the core headers.
mutt_strwidth
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition curs_lib.c:449
menu_redraw_current
void menu_redraw_current(struct Menu *menu)
Redraw the current menu.
Definition draw.c:453
get_color
static const struct AttrColor * get_color(int index, unsigned char *s)
Choose a colour for a line of the index.
Definition draw.c:53
menu_redraw_index
void menu_redraw_index(struct Menu *menu)
Force the redraw of the index.
Definition draw.c:330
menu_redraw
int menu_redraw(struct Menu *menu)
Redraw the parts of the screen that have been flagged to be redrawn.
Definition draw.c:488
menu_redraw_full
void menu_redraw_full(struct Menu *menu)
Force the redraw of the Menu.
Definition draw.c:316
menu_pad_string
static void menu_pad_string(struct Menu *menu, struct Buffer *buf)
Pad a string with spaces for display in the Menu.
Definition draw.c:294
print_enriched_string
static void print_enriched_string(struct MuttWindow *win, int index, const struct AttrColor *ac_def, struct AttrColor *ac_ind, struct Buffer *buf, struct ConfigSubset *sub)
Display a string with embedded colours and graphics.
Definition draw.c:114
menu_redraw_motion
void menu_redraw_motion(struct Menu *menu)
Force the redraw of the list part of the menu.
Definition draw.c:394
lib.h
Structs that make up an email.
lib.h
Convenience wrapper for the gui headers.
MUTT_TREE_MAX
@ MUTT_TREE_MAX
Definition thread.h:70
MUTT_TREE_LLCORNER
@ MUTT_TREE_LLCORNER
Lower left corner.
Definition thread.h:57
MUTT_TREE_RARROW
@ MUTT_TREE_RARROW
Right arrow.
Definition thread.h:63
MUTT_SPECIAL_INDEX
@ MUTT_SPECIAL_INDEX
Colour indicator.
Definition thread.h:72
MUTT_TREE_ULCORNER
@ MUTT_TREE_ULCORNER
Upper left corner.
Definition thread.h:58
MUTT_TREE_EQUALS
@ MUTT_TREE_EQUALS
Equals (for threads).
Definition thread.h:66
MUTT_TREE_HIDDEN
@ MUTT_TREE_HIDDEN
Ampersand character (for threads).
Definition thread.h:65
MUTT_TREE_STAR
@ MUTT_TREE_STAR
Star character (for threads).
Definition thread.h:64
MUTT_TREE_LTEE
@ MUTT_TREE_LTEE
Left T-piece.
Definition thread.h:59
MUTT_TREE_VLINE
@ MUTT_TREE_VLINE
Vertical line.
Definition thread.h:61
MUTT_TREE_MISSING
@ MUTT_TREE_MISSING
Question mark.
Definition thread.h:69
MUTT_TREE_TTEE
@ MUTT_TREE_TTEE
Top T-piece.
Definition thread.h:67
MUTT_TREE_HLINE
@ MUTT_TREE_HLINE
Horizontal line.
Definition thread.h:60
MUTT_TREE_SPACE
@ MUTT_TREE_SPACE
Blank space.
Definition thread.h:62
MUTT_TREE_BTEE
@ MUTT_TREE_BTEE
Bottom T-piece.
Definition thread.h:68
mutt_hash_find
void * mutt_hash_find(const struct HashTable *table, const char *strkey)
Find the HashElem data in a Hash Table element using a key.
Definition hash.c:365
lib.h
GUI manage the main index (list of emails).
get_current_mailbox
struct Mailbox * get_current_mailbox(void)
Get the current Mailbox.
Definition index.c:725
lib.h
GUI present the user with a selectable list.
MENU_REDRAW_INDEX
@ MENU_REDRAW_INDEX
Redraw the index.
Definition lib.h:61
MENU_REDRAW_FULL
@ MENU_REDRAW_FULL
Redraw everything.
Definition lib.h:64
MENU_REDRAW_CURRENT
@ MENU_REDRAW_CURRENT
Redraw the current line of the menu.
Definition lib.h:63
MENU_REDRAW_NONE
@ MENU_REDRAW_NONE
No flags are set.
Definition lib.h:60
MENU_REDRAW_MOTION
@ MENU_REDRAW_MOTION
Redraw after moving the menu list.
Definition lib.h:62
merged_color_overlay
const struct AttrColor * merged_color_overlay(const struct AttrColor *base, const struct AttrColor *over)
Combine two colours.
Definition merged.c:110
MODULE_ID_EMAIL
@ MODULE_ID_EMAIL
ModuleEmail, Email code
Definition module_api.h:64
CharsetIsUtf8
bool CharsetIsUtf8
Is the user's current character set utf-8?
Definition charset.c:67
lib.h
Convenience wrapper for the library headers.
mutt_str_len
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition string.c:503
mutt_curses_set_color_by_id
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
mutt_curses_set_color
void mutt_curses_set_color(const struct AttrColor *ac)
Set the colour and attributes for text.
Definition mutt_curses.c:38
mutt_window_clear
void mutt_window_clear(struct MuttWindow *win)
Clear a Window.
Definition mutt_window.c:716
mutt_window_printf
int mutt_window_printf(struct MuttWindow *win, const char *fmt,...)
Write a formatted string to a Window.
Definition mutt_window.c:413
mutt_window_move
int mutt_window_move(struct MuttWindow *win, int row, int col)
Move the cursor in a Window.
Definition mutt_window.c:312
mutt_window_clearline
void mutt_window_clearline(struct MuttWindow *win, int row)
Clear a row of a Window.
Definition mutt_window.c:247
mutt_window_addstr
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition mutt_window.c:398
mutt_window_addnstr
int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
Write a partial string to a Window.
Definition mutt_window.c:383
mutt_window_addch
int mutt_window_addch(struct MuttWindow *win, int ch)
Write one character to a Window.
Definition mutt_window.c:370
mutt_get_virt_email
struct Email * mutt_get_virt_email(struct Mailbox *m, int vnum)
Get a virtual Email.
Definition mview.c:378
neomutt_get_module_data
void * neomutt_get_module_data(struct NeoMutt *n, enum ModuleId id)
Get the private data for a Module.
Definition neomutt.c:666
mutt_pattern_exec
bool mutt_pattern_exec(struct Pattern *pat, PatternExecFlags flags, struct Mailbox *m, struct Email *e, struct PatternCache *cache)
Match a pattern against an email header.
Definition exec.c:1156
lib.h
Match patterns to emails.
MUTT_MATCH_FULL_ADDRESS
@ MUTT_MATCH_FULL_ADDRESS
Match the full address.
Definition lib.h:117
buf_pool_get
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition pool.c:91
buf_pool_release
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition pool.c:111
STAILQ_FOREACH
#define STAILQ_FOREACH(var, head, field)
Definition queue.h:390
SLIST_FIRST
#define SLIST_FIRST(head)
Definition queue.h:227
ASSERT
#define ASSERT(COND)
Definition signal2.h:59
AttrColor
A curses colour and its attributes.
Definition attr.h:65
Buffer
String manipulation buffer.
Definition buffer.h:36
Buffer::data
char * data
Pointer to data.
Definition buffer.h:37
ConfigSubset
A set of inherited config items.
Definition subset.h:46
EmailModuleData
Email private Module data.
Definition module_data.h:32
EmailModuleData::tag_transforms
struct HashTable * tag_transforms
Hash Table: "inbox" -> "i" - Alternative tag names.
Definition module_data.h:42
Email
The envelope/body of an email.
Definition email.h:39
Email::index
int index
The absolute (unsorted) message number.
Definition email.h:110
Mailbox
A mailbox.
Definition mailbox.h:81
Menu
Definition lib.h:86
Menu::win
struct MuttWindow * win
Window holding the Menu.
Definition lib.h:94
Menu::current
int current
Current entry.
Definition lib.h:87
Menu::color
const struct AttrColor *(* color)(struct Menu *menu, int line)
Definition lib.h:151
Menu::redraw
MenuRedrawFlags redraw
When to redraw the screen.
Definition lib.h:89
Menu::show_indicator
bool show_indicator
Show the Indicator colour.
Definition lib.h:93
Menu::top
int top
Entry that is the top of the current page.
Definition lib.h:98
Menu::make_entry
int(* make_entry)(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Definition lib.h:114
Menu::sub
struct ConfigSubset * sub
Inherited config items.
Definition lib.h:95
Menu::page_len
int page_len
Number of entries per screen.
Definition lib.h:91
Menu::old_current
int old_current
For driver use only.
Definition lib.h:99
MuttWindow::state
struct WindowState state
Current state of the Window.
Definition mutt_window.h:133
NeoMutt
Container for Accounts, Notifications.
Definition neomutt.h:41
RegexColor
A regular expression and a color to highlight a line.
Definition regex4.h:37
RegexColor::color_pattern
struct PatternList * color_pattern
Compiled pattern to speed up index color calculation.
Definition regex4.h:42
RegexColor::attr_color
struct AttrColor attr_color
Colour and attributes to apply.
Definition regex4.h:38
RegexColor::pattern
char * pattern
Pattern to match.
Definition regex4.h:39
WindowState::cols
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition mutt_window.h:60
WindowState::rows
short rows
Number of rows, can be MUTT_WIN_SIZE_UNLIMITED.
Definition mutt_window.h:61