NeoMutt  2024-10-02-19-gb00cc4
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
recalc()

Recalculate the Window data. More...

+ Collaboration diagram for recalc():

Functions

int alias_recalc (struct MuttWindow *win)
 Recalculate the display of the Alias Window - Implements MuttWindow::recalc() -.
 
static int cbar_recalc (struct MuttWindow *win)
 Recalculate the Window data - Implements MuttWindow::recalc() -.
 
static int enter_recalc (struct MuttWindow *win)
 Recalculate the Window data - Implements MuttWindow::recalc() -.
 
static int env_recalc (struct MuttWindow *win)
 Recalculate the Window data - Implements MuttWindow::recalc() -.
 
static int msgwin_recalc (struct MuttWindow *win)
 Recalculate the display of the Message Window - Implements MuttWindow::recalc() -.
 
static int sbar_recalc (struct MuttWindow *win)
 Recalculate the Window data - Implements MuttWindow::recalc() -.
 
static int helpbar_recalc (struct MuttWindow *win)
 Recalculate the display of the Help Bar - Implements MuttWindow::recalc() -.
 
static int ibar_recalc (struct MuttWindow *win)
 Recalculate the Window data - Implements MuttWindow::recalc() -.
 
static int index_recalc (struct MuttWindow *win)
 Recalculate the Index display - Implements MuttWindow::recalc() -.
 
static int menu_recalc (struct MuttWindow *win)
 Recalculate the Window data - Implements MuttWindow::recalc() -.
 
static int pager_recalc (struct MuttWindow *win)
 Recalculate the Pager display - Implements MuttWindow::recalc() -.
 
static int pbar_recalc (struct MuttWindow *win)
 Recalculate the Window data - Implements MuttWindow::recalc() -.
 
static int progress_window_recalc (struct MuttWindow *win)
 Recalculate the Progress Bar - Implements MuttWindow::recalc() -.
 
int sb_recalc (struct MuttWindow *win)
 Recalculate the Sidebar display - Implements MuttWindow::recalc() -.
 

Detailed Description

Recalculate the Window data.

Parameters
winWindow
Return values
0Success
-1Error
Precondition
win is not NULL
win is visible

Function Documentation

◆ alias_recalc()

int alias_recalc ( struct MuttWindow win)

Recalculate the display of the Alias Window - Implements MuttWindow::recalc() -.

Definition at line 89 of file gui.c.

90{
91 struct Menu *menu = win->wdata;
92 struct AliasMenuData *mdata = menu->mdata;
93
94 alias_array_sort(&mdata->ava, mdata->sub);
95
97 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
98 return 0;
99}
void alias_array_sort(struct AliasViewArray *ava, const struct ConfigSubset *sub)
Sort and reindex an AliasViewArray.
Definition: sort.c:168
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
#define WA_REPAINT
Redraw the contents of the Window.
Definition: mutt_window.h:110
AliasView array wrapper with Pattern information -.
Definition: gui.h:54
struct Menu * menu
Menu.
Definition: gui.h:58
Definition: lib.h:79
struct MuttWindow * win
Window holding the Menu.
Definition: lib.h:86
void * mdata
Private data.
Definition: lib.h:147
void * wdata
Private data.
Definition: mutt_window.h:144
WindowActionFlags actions
Actions to be performed, e.g. WA_RECALC.
Definition: mutt_window.h:131
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ cbar_recalc()

static int cbar_recalc ( struct MuttWindow win)
static

Recalculate the Window data - Implements MuttWindow::recalc() -.

See also
$compose_format

Definition at line 153 of file cbar.c.

154{
155 struct Buffer *buf = buf_pool_get();
156 struct ComposeSharedData *shared = win->parent->wdata;
157
158 const struct Expando *c_compose_format = cs_subset_expando(shared->sub, "compose_format");
159 expando_filter(c_compose_format, ComposeRenderData, shared,
160 MUTT_FORMAT_NO_FLAGS, win->state.cols, buf);
161
162 struct ComposeBarData *cbar_data = win->wdata;
163 if (!mutt_str_equal(buf_string(buf), cbar_data->compose_format))
164 {
165 mutt_str_replace(&cbar_data->compose_format, buf_string(buf));
166 win->actions |= WA_REPAINT;
167 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
168 }
169 buf_pool_release(&buf);
170
171 return 0;
172}
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
const struct ExpandoRenderData ComposeRenderData[]
Callbacks for Compose Expandos.
Definition: cbar.c:81
const struct Expando * cs_subset_expando(const struct ConfigSubset *sub, const char *name)
Get an Expando config item by name.
Definition: config_type.c:357
int expando_filter(const struct Expando *exp, const struct ExpandoRenderData *rdata, void *data, MuttFormatFlags flags, int max_cols, struct Buffer *buf)
Render an Expando and run the result through a filter.
Definition: filter.c:141
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:280
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: render.h:33
String manipulation buffer.
Definition: buffer.h:36
Data to fill the Compose Bar Window.
Definition: cbar_data.h:34
char * compose_format
Cached status string.
Definition: cbar_data.h:35
Shared Compose Data.
Definition: shared_data.h:35
struct ConfigSubset * sub
Config set to use.
Definition: shared_data.h:36
Parsed Expando trees.
Definition: expando.h:41
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:126
struct MuttWindow * parent
Parent Window.
Definition: mutt_window.h:134
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_recalc()

static int enter_recalc ( struct MuttWindow win)
static

Recalculate the Window data - Implements MuttWindow::recalc() -.

See also
$compose_format

Definition at line 175 of file window.c.

176{
177 win->actions |= WA_REPAINT;
178 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
179
180 return 0;
181}
+ Here is the caller graph for this function:

◆ env_recalc()

static int env_recalc ( struct MuttWindow win)
static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 720 of file window.c.

721{
722 struct EnvelopeWindowData *wdata = win->wdata;
723
724 const int cur_rows = win->state.rows;
725 const int new_rows = calc_envelope(win, wdata);
726
727 if (new_rows != cur_rows)
728 {
729 win->req_rows = new_rows;
731 }
732
733 win->actions |= WA_REPAINT;
734 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
735 return 0;
736}
static int calc_envelope(struct MuttWindow *win, struct EnvelopeWindowData *wdata)
Calculate how many rows the envelope will need.
Definition: window.c:304
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:343
Data to fill the Envelope Window.
Definition: wdata.h:38
short req_rows
Number of rows required.
Definition: mutt_window.h:124
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:

◆ msgwin_recalc()

static int msgwin_recalc ( struct MuttWindow win)
static

Recalculate the display of the Message Window - Implements MuttWindow::recalc() -.

Definition at line 161 of file msgwin.c.

162{
163 win->actions |= WA_REPAINT;
164 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
165 return 0;
166}
+ Here is the caller graph for this function:

◆ sbar_recalc()

static int sbar_recalc ( struct MuttWindow win)
static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 82 of file sbar.c.

83{
84 if (!win)
85 return -1;
86
87 win->actions |= WA_REPAINT;
88 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
89 return 0;
90}
+ Here is the caller graph for this function:

◆ helpbar_recalc()

static int helpbar_recalc ( struct MuttWindow win)
static

Recalculate the display of the Help Bar - Implements MuttWindow::recalc() -.

Generate the help string from data on the focused Window. The Help Bar isn't drawn, yet.

Definition at line 142 of file helpbar.c.

143{
145 if (!wdata)
146 return 0;
147
148 FREE(&wdata->help_str);
149
150 struct MuttWindow *win_focus = window_get_focus();
151 if (!win_focus)
152 return 0;
153
154 // Ascend the Window tree until we find help_data
155 while (win_focus && !win_focus->help_data)
156 win_focus = win_focus->parent;
157
158 if (!win_focus)
159 return 0;
160
161 char helpstr[1024] = { 0 };
162 compile_help(helpstr, sizeof(helpstr), win_focus->help_menu, win_focus->help_data);
163
164 wdata->help_menu = win_focus->help_menu;
165 wdata->help_data = win_focus->help_data;
166 wdata->help_str = mutt_str_dup(helpstr);
167
168 win->actions |= WA_REPAINT;
169 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
170 return 0;
171}
struct HelpbarWindowData * helpbar_wdata_get(struct MuttWindow *win)
Get the Helpbar data for this window.
Definition: wdata.c:64
static char * compile_help(char *buf, size_t buflen, enum MenuType menu, const struct Mapping *items)
Create the text for the help menu.
Definition: helpbar.c:115
#define FREE(x)
Definition: memory.h:45
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
struct MuttWindow * window_get_focus(void)
Get the currently focused Window.
Definition: mutt_window.c:667
Help Bar Window data -.
Definition: private.h:34
const struct Mapping * help_data
Data for the Help Bar.
Definition: mutt_window.h:141
int help_menu
Menu for key bindings, e.g. MENU_PAGER.
Definition: mutt_window.h:140
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ibar_recalc()

static int ibar_recalc ( struct MuttWindow win)
static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 90 of file ibar.c.

91{
92 struct Buffer *buf = buf_pool_get();
93
94 struct IBarPrivateData *ibar_data = win->wdata;
95 struct IndexSharedData *shared = ibar_data->shared;
96 struct IndexPrivateData *priv = ibar_data->priv;
97
98 const struct Expando *c_status_format = cs_subset_expando(shared->sub, "status_format");
99 menu_status_line(buf, shared, priv->menu, win->state.cols, c_status_format);
100
101 if (!mutt_str_equal(buf_string(buf), ibar_data->status_format))
102 {
103 mutt_str_replace(&ibar_data->status_format, buf_string(buf));
104 win->actions |= WA_REPAINT;
105 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
106 }
107
108 const bool c_ts_enabled = cs_subset_bool(shared->sub, "ts_enabled");
109 if (c_ts_enabled && TsSupported)
110 {
111 buf_reset(buf);
112 const struct Expando *c_ts_status_format = cs_subset_expando(shared->sub, "ts_status_format");
113 menu_status_line(buf, shared, priv->menu, -1, c_ts_status_format);
114 if (!mutt_str_equal(buf_string(buf), ibar_data->ts_status_format))
115 {
117 win->actions |= WA_REPAINT;
118 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
119 }
120
121 buf_reset(buf);
122 const struct Expando *c_ts_icon_format = cs_subset_expando(shared->sub, "ts_icon_format");
123 menu_status_line(buf, shared, priv->menu, -1, c_ts_icon_format);
124 if (!mutt_str_equal(buf_string(buf), ibar_data->ts_icon_format))
125 {
126 mutt_str_replace(&ibar_data->ts_icon_format, buf_string(buf));
127 win->actions |= WA_REPAINT;
128 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
129 }
130 }
131
132 buf_pool_release(&buf);
133 return 0;
134}
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
void menu_status_line(struct Buffer *buf, struct IndexSharedData *shared, struct Menu *menu, int max_cols, const struct Expando *exp)
Create the status line.
Definition: status.c:496
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
struct IndexPrivateData * priv
Private Index data.
Definition: ibar.c:81
Private state data for the Index.
Definition: private_data.h:35
struct Menu * menu
Menu controlling the index.
Definition: private_data.h:41
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
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ index_recalc()

static int index_recalc ( struct MuttWindow win)
static

Recalculate the Index display - Implements MuttWindow::recalc() -.

Definition at line 587 of file index.c.

588{
589 win->actions |= WA_REPAINT;
590 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
591 return 0;
592}
+ Here is the caller graph for this function:

◆ menu_recalc()

static int menu_recalc ( struct MuttWindow win)
static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 80 of file window.c.

81{
82 if (win->type != WT_MENU)
83 return 0;
84
85 win->actions |= WA_REPAINT;
86 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
87 return 0;
88}
@ WT_MENU
An Window containing a Menu.
Definition: mutt_window.h:97
enum WindowType type
Window type, e.g. WT_SIDEBAR.
Definition: mutt_window.h:143
+ Here is the caller graph for this function:

◆ pager_recalc()

static int pager_recalc ( struct MuttWindow win)
static

Recalculate the Pager display - Implements MuttWindow::recalc() -.

Definition at line 121 of file pager.c.

122{
123 win->actions |= WA_REPAINT;
124 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
125 return 0;
126}
+ Here is the caller graph for this function:

◆ pbar_recalc()

static int pbar_recalc ( struct MuttWindow win)
static

Recalculate the Window data - Implements MuttWindow::recalc() -.

Definition at line 92 of file pbar.c.

93{
94 struct PBarPrivateData *pbar_data = win->wdata;
95 struct IndexSharedData *shared = pbar_data->shared;
96 struct PagerPrivateData *priv = pbar_data->priv;
97 if (!priv || !priv->pview)
98 return 0;
99
100 struct Buffer *buf = buf_pool_get();
101 char pager_progress_str[65] = { 0 }; /* Lots of space for translations */
102
103 long offset;
104 if (priv->lines && (priv->cur_line <= priv->lines_used))
105 offset = priv->lines[priv->cur_line].offset;
106 else
107 offset = priv->bytes_read;
108
109 if (offset < (priv->st.st_size - 1))
110 {
111 const long percent = (100 * offset) / priv->st.st_size;
112 /* L10N: Pager position percentage.
113 `%ld` is the number, `%%` is the percent symbol.
114 They may be reordered, or space inserted, if you wish. */
115 snprintf(pager_progress_str, sizeof(pager_progress_str), _("%ld%%"), percent);
116 }
117 else
118 {
119 const char *msg = (priv->top_line == 0) ?
120 /* L10N: Status bar message: the entire email is visible in the pager */
121 _("all") :
122 /* L10N: Status bar message: the end of the email is visible in the pager */
123 _("end");
124 mutt_str_copy(pager_progress_str, msg, sizeof(pager_progress_str));
125 }
126
127 if ((priv->pview->mode == PAGER_MODE_EMAIL) || (priv->pview->mode == PAGER_MODE_ATTACH_E))
128 {
129 int msg_in_pager = shared->mailbox_view ? shared->mailbox_view->msg_in_pager : -1;
130
131 const struct Expando *c_pager_format = cs_subset_expando(shared->sub, "pager_format");
132 mutt_make_string(buf, win->state.cols, c_pager_format, shared->mailbox, msg_in_pager,
133 shared->email, MUTT_FORMAT_NO_FLAGS, pager_progress_str);
134 }
135 else
136 {
137 buf_printf(buf, "%s (%s)", priv->pview->banner, pager_progress_str);
138 }
139
140 if (!mutt_str_equal(buf_string(buf), pbar_data->pager_format))
141 {
142 mutt_str_replace(&pbar_data->pager_format, buf_string(buf));
143 win->actions |= WA_REPAINT;
144 }
145
146 buf_pool_release(&buf);
147 return 0;
148}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
int mutt_make_string(struct Buffer *buf, size_t max_cols, const struct Expando *exp, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1740
#define _(a)
Definition: message.h:28
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:581
@ PAGER_MODE_EMAIL
Pager is invoked via 1st path. The mime part is selected automatically.
Definition: lib.h:138
@ PAGER_MODE_ATTACH_E
A special case of PAGER_MODE_ATTACH - attachment is a full-blown email message.
Definition: lib.h:140
struct Email * email
Currently selected Email.
Definition: shared_data.h:42
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:41
struct MailboxView * mailbox_view
Current Mailbox view.
Definition: shared_data.h:40
LOFF_T offset
Offset into Email file (PagerPrivateData->fp)
Definition: display.h:52
int msg_in_pager
Message currently shown in the pager.
Definition: mview.h:45
Data to draw the Pager Bar.
Definition: pbar.c:83
struct PagerPrivateData * priv
Private Pager data.
Definition: pbar.c:85
char * pager_format
Cached status string.
Definition: pbar.c:86
struct IndexSharedData * shared
Shared Index data.
Definition: pbar.c:84
Private state data for the Pager.
Definition: private_data.h:41
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
struct Line * lines
Array of text lines in pager.
Definition: private_data.h:48
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 PagerView * pview
Object to view in the pager.
Definition: private_data.h:42
enum PagerMode mode
Pager mode.
Definition: lib.h:174
const char * banner
Title to display in status bar.
Definition: lib.h:176
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ progress_window_recalc()

static int progress_window_recalc ( struct MuttWindow win)
static

Recalculate the Progress Bar - Implements MuttWindow::recalc() -.

Definition at line 135 of file window.c.

136{
137 if (!win || !win->wdata)
138 return -1;
139
140 struct ProgressWindowData *wdata = win->wdata;
141 wdata->display_pos = wdata->update_pos;
142 wdata->display_time = wdata->update_time;
143
144 if (wdata->is_bytes)
145 mutt_str_pretty_size(wdata->pretty_pos, sizeof(wdata->pretty_pos), wdata->display_pos);
146
147 if ((wdata->update_percent < 0) && (wdata->size != 0))
148 wdata->display_percent = 100 * wdata->display_pos / wdata->size;
149 else
150 wdata->display_percent = wdata->update_percent;
151
153 return 0;
154}
void mutt_str_pretty_size(char *buf, size_t buflen, size_t num)
Display an abbreviated size, like 3.4K.
Definition: muttlib.c:1004
Progress Bar Window Data.
Definition: wdata.h:36
int update_percent
Updated percentage complete.
Definition: wdata.h:55
size_t size
Total expected size.
Definition: wdata.h:42
char pretty_pos[24]
Pretty string for the position.
Definition: wdata.h:51
uint64_t update_time
Time of last update.
Definition: wdata.h:56
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
size_t update_pos
Updated position.
Definition: wdata.h:54
struct MuttWindow * win
Window to draw on.
Definition: wdata.h:37
uint64_t display_time
Time of last display.
Definition: wdata.h:50
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ sb_recalc()

int sb_recalc ( struct MuttWindow win)

Recalculate the Sidebar display - Implements MuttWindow::recalc() -.

Definition at line 777 of file window.c.

778{
780 struct IndexSharedData *shared = wdata->shared;
781
782 if (ARRAY_EMPTY(&wdata->entries))
783 {
784 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
786 struct MailboxNode *np = NULL;
787 STAILQ_FOREACH(np, &ml, entries)
788 {
789 if (np->mailbox->visible)
790 sb_add_mailbox(wdata, np->mailbox);
791 }
793 }
794
795 if (!prepare_sidebar(wdata, win->state.rows))
796 {
797 win->actions |= WA_REPAINT;
798 return 0;
799 }
800
801 int num_rows = win->state.rows;
802 int num_cols = win->state.cols;
803
804 if (ARRAY_EMPTY(&wdata->entries) || (num_rows <= 0))
805 return 0;
806
807 if (wdata->top_index < 0)
808 return 0;
809
810 int width = num_cols - wdata->divider_width;
811 int row = 0;
812 struct Mailbox *m_cur = shared->mailbox;
813 struct SbEntry **sbep = NULL;
814 ARRAY_FOREACH_FROM(sbep, &wdata->entries, wdata->top_index)
815 {
816 if (row >= num_rows)
817 break;
818
819 if ((*sbep)->is_hidden)
820 continue;
821
822 struct SbEntry *entry = (*sbep);
823 struct Mailbox *m = entry->mailbox;
824
825 const int entryidx = ARRAY_FOREACH_IDX;
826 entry->color = calc_color(m, (entryidx == wdata->opn_index),
827 (entryidx == wdata->hil_index));
828
829 if (m_cur && (m_cur->realpath[0] != '\0') &&
830 mutt_str_equal(m->realpath, m_cur->realpath))
831 {
832 m->msg_unread = m_cur->msg_unread;
833 m->msg_count = m_cur->msg_count;
834 m->msg_flagged = m_cur->msg_flagged;
835 }
836
837 const char *path = mailbox_path(m);
838
839 const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
840 // Try to abbreviate the full path
841 const char *abbr = abbrev_folder(path, c_folder, m->type);
842 if (!abbr)
843 abbr = abbrev_url(path, m->type);
844 const char *short_path = abbr ? abbr : path;
845
846 /* Compute the depth */
847 const char *last_part = abbr;
848 const char *const c_sidebar_delim_chars = cs_subset_string(NeoMutt->sub, "sidebar_delim_chars");
849 entry->depth = calc_path_depth(abbr, c_sidebar_delim_chars, &last_part);
850
851 const bool short_path_is_abbr = (short_path == abbr);
852 const bool c_sidebar_short_path = cs_subset_bool(NeoMutt->sub, "sidebar_short_path");
853 if (c_sidebar_short_path)
854 {
855 short_path = last_part;
856 }
857
858 // Don't indent if we were unable to create an abbreviation.
859 // Otherwise, the full path will be indent, and it looks unusual.
860 const bool c_sidebar_folder_indent = cs_subset_bool(NeoMutt->sub, "sidebar_folder_indent");
861 if (c_sidebar_folder_indent && short_path_is_abbr)
862 {
863 const short c_sidebar_component_depth = cs_subset_number(NeoMutt->sub, "sidebar_component_depth");
864 if (c_sidebar_component_depth > 0)
865 entry->depth -= c_sidebar_component_depth;
866 }
867 else if (!c_sidebar_folder_indent)
868 {
869 entry->depth = 0;
870 }
871
872 mutt_str_copy(entry->box, short_path, sizeof(entry->box));
873 make_sidebar_entry(entry->display, sizeof(entry->display), width, entry, shared);
874 row++;
875 }
876
877 win->actions |= WA_REPAINT;
878 mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
879 return 0;
880}
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:74
#define ARRAY_FOREACH_FROM(elem, head, from)
Iterate from an index to the end.
Definition: array.h:223
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:143
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
@ MUTT_MAILBOX_ANY
Match any Mailbox type.
Definition: mailbox.h:42
void neomutt_mailboxlist_clear(struct MailboxList *ml)
Free a Mailbox List.
Definition: neomutt.c:168
size_t neomutt_mailboxlist_get_all(struct MailboxList *head, struct NeoMutt *n, enum MailboxType type)
Get a List of all Mailboxes.
Definition: neomutt.c:191
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
void sb_add_mailbox(struct SidebarWindowData *wdata, struct Mailbox *m)
Add a Mailbox to the Sidebar.
Definition: sidebar.c:88
struct SidebarWindowData * sb_wdata_get(struct MuttWindow *win)
Get the Sidebar data for this window.
Definition: wdata.c:77
static const char * abbrev_url(const char *mbox, enum MailboxType type)
Abbreviate a url-style Mailbox path.
Definition: window.c:203
static const struct AttrColor * calc_color(const struct Mailbox *m, bool current, bool highlight)
Calculate the colour of a Sidebar row.
Definition: window.c:250
static const char * abbrev_folder(const char *mbox, const char *folder, enum MailboxType type)
Abbreviate a Mailbox path using a folder.
Definition: window.c:139
static int calc_path_depth(const char *mbox, const char *delims, const char **last_part)
Calculate the depth of a Mailbox path.
Definition: window.c:313
static bool prepare_sidebar(struct SidebarWindowData *wdata, int page_size)
Prepare the list of SbEntry's for the sidebar display.
Definition: window.c:692
static void make_sidebar_entry(char *buf, size_t buflen, int width, struct SbEntry *sbe, struct IndexSharedData *shared)
Turn mailbox data into a sidebar string.
Definition: window.c:586
List of Mailboxes.
Definition: mailbox.h:166
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:167
A mailbox.
Definition: mailbox.h:79
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:81
int msg_count
Total number of messages.
Definition: mailbox.h:88
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
bool visible
True if a result of "mailboxes".
Definition: mailbox.h:130
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:90
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
Info about folders in the sidebar.
Definition: private.h:41
const struct AttrColor * color
Colour to use.
Definition: private.h:47
int depth
Indentation depth.
Definition: private.h:44
char display[256]
Formatted string to display.
Definition: private.h:43
struct Mailbox * mailbox
Mailbox this represents.
Definition: private.h:45
char box[256]
Mailbox path (possibly abbreviated)
Definition: private.h:42
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
int hil_index
Highlighted mailbox.
Definition: private.h:95
struct IndexSharedData * shared
Shared Index Data.
Definition: private.h:90
int opn_index
Current (open) mailbox.
Definition: private.h:94
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: