NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
window.c
Go to the documentation of this file.
1
56#include "config.h"
57#include <stdarg.h>
58#include <stdbool.h>
59#include <stdint.h>
60#include <stdio.h>
61#include "mutt/lib.h"
62#include "gui/lib.h"
63#include "color/lib.h"
64#include "expando/lib.h"
65#include "muttlib.h"
66#include "wdata.h"
67
75static void message_bar(struct MuttWindow *win, int percent, const char *fmt, ...)
76{
77 if (!fmt || !win || !win->wdata)
78 return;
79
80 va_list ap;
81 char buf[1024] = { 0 };
82 struct Buffer *buf2 = buf_pool_get();
83 int w = (percent * win->state.cols) / 100;
84 size_t l;
85
86 va_start(ap, fmt);
87 vsnprintf(buf, sizeof(buf), fmt, ap);
88 l = mutt_strwidth(buf);
89 va_end(ap);
90
91 format_string(buf2, 0, win->state.cols - 2, JUSTIFY_LEFT, 0, buf, sizeof(buf), false);
92
93 mutt_window_move(win, 0, 0);
94
95 if ((percent != -1) && simple_color_is_set(MT_COLOR_PROGRESS))
96 {
97 if (l < w)
98 {
99 /* The string fits within the colour bar */
101 mutt_window_addstr(win, buf_string(buf2));
102 w -= l;
103 while (w-- > 0)
104 {
105 mutt_window_addch(win, ' ');
106 }
108 }
109 else
110 {
111 /* The string is too long for the colour bar */
112 int off = mutt_wstr_trunc(buf_string(buf2), buf2->dsize, w, NULL);
113
114 char ch = buf_at(buf2, off);
115 buf2->data[off] = '\0';
117 mutt_window_addstr(win, buf_string(buf2));
118 buf2->data[off] = ch;
120 mutt_window_addstr(win, buf2->data + off);
121 }
122 }
123 else
124 {
125 mutt_window_addstr(win, buf_string(buf2));
126 }
127
129 buf_pool_release(&buf2);
130}
131
135static int progress_window_recalc(struct MuttWindow *win)
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}
155
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}
225
232static bool percent_needs_update(const struct ProgressWindowData *wdata, int percent)
233{
234 return (percent > wdata->display_percent);
235}
236
243static bool pos_needs_update(const struct ProgressWindowData *wdata, long pos)
244{
245 const unsigned shift = wdata->is_bytes ? 10 : 0;
246 return pos >= (wdata->display_pos + (wdata->size_inc << shift));
247}
248
255static bool time_needs_update(const struct ProgressWindowData *wdata, size_t now)
256{
257 if (wdata->time_inc == 0)
258 return true;
259
260 if (now < wdata->display_time)
261 return true;
262
263 const size_t elapsed = (now - wdata->display_time);
264 return (wdata->time_inc < elapsed);
265}
266
274bool progress_window_update(struct MuttWindow *win, size_t pos, int percent)
275{
276 if (!win || !win->wdata)
277 return false;
278
279 struct ProgressWindowData *wdata = win->wdata;
280
281 if (percent >= 0)
282 {
283 if (!percent_needs_update(wdata, percent))
284 return false;
285 }
286 else
287 {
288 if (!pos_needs_update(wdata, pos))
289 return false;
290 }
291
292 const uint64_t now = mutt_date_now_ms();
293 if (!time_needs_update(wdata, now))
294 return false;
295
296 wdata->update_pos = pos;
297 wdata->update_percent = percent;
298 wdata->update_time = now;
300 return true;
301}
302
311struct MuttWindow *progress_window_new(size_t size, size_t size_inc,
312 size_t time_inc, bool is_bytes)
313{
314 if (size_inc == 0) // The user has disabled the progress bar
315 return NULL;
316
322 win->actions |= WA_RECALC;
323
324 struct ProgressWindowData *wdata = progress_wdata_new();
325 wdata->win = win;
326 wdata->size = size;
327 wdata->size_inc = size_inc;
328 wdata->time_inc = time_inc;
329 wdata->is_bytes = is_bytes;
330
331 if (is_bytes)
332 mutt_str_pretty_size(wdata->pretty_size, sizeof(wdata->pretty_size), size);
333
334 win->wdata = wdata;
336
337 return win;
338}
339
346void progress_window_set_message(struct MuttWindow *win, const char *fmt, va_list ap)
347{
348 if (!win || !win->wdata || !fmt)
349 return;
350
351 struct ProgressWindowData *wdata = win->wdata;
352
353 vsnprintf(wdata->msg, sizeof(wdata->msg), fmt, ap);
354
356}
357
364{
365 if (!win || !win->wdata)
366 return;
367
368 struct ProgressWindowData *wdata = win->wdata;
369
370 wdata->size = size;
371 wdata->display_pos = 0;
372 wdata->display_percent = 0;
373 wdata->display_time = 0;
375}
char buf_at(const struct Buffer *buf, size_t offset)
Return the character at the given offset.
Definition: buffer.c:670
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
Color and attribute parsing.
bool simple_color_is_set(enum ColorId cid)
Is the object coloured?
Definition: simple.c:109
@ MT_COLOR_PROGRESS
Progress bar.
Definition: color.h:61
@ MT_COLOR_NORMAL
Plain text.
Definition: color.h:59
size_t mutt_wstr_trunc(const char *src, size_t maxlen, size_t maxwid, size_t *width)
Work out how to truncate a widechar string.
Definition: curs_lib.c:383
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:443
Parse Expando string.
int format_string(struct Buffer *buf, int min_cols, int max_cols, enum FormatJustify justify, char pad_char, const char *str, size_t n, bool arboreal)
Format a string, like snprintf()
Definition: format.c:108
@ JUSTIFY_LEFT
Left justify the text.
Definition: format.h:34
static int progress_window_recalc(struct MuttWindow *win)
Recalculate the Progress Bar - Implements MuttWindow::recalc() -.
Definition: window.c:135
static int progress_window_repaint(struct MuttWindow *win)
Repaint the Progress Bar - Implements MuttWindow::repaint() -.
Definition: window.c:159
void progress_wdata_free(struct MuttWindow *win, void **ptr)
Free Progress Bar Window data - Implements MuttWindow::wdata_free() -.
Definition: wdata.c:45
Convenience wrapper for the gui headers.
uint64_t mutt_date_now_ms(void)
Return the number of milliseconds since the Unix epoch.
Definition: date.c:465
Convenience wrapper for the library headers.
#define _(a)
Definition: message.h:28
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
struct MuttWindow * mutt_window_new(enum WindowType type, enum MuttWindowOrientation orient, enum MuttWindowSize size, int cols, int rows)
Create a new Window.
Definition: mutt_window.c:182
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:297
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition: mutt_window.c:416
void mutt_window_clrtoeol(struct MuttWindow *win)
Clear to the end of the line.
Definition: mutt_window.c:244
int mutt_window_addch(struct MuttWindow *win, int ch)
Write one character to a Window.
Definition: mutt_window.c:388
#define WA_RECALC
Recalculate the contents of the Window.
Definition: mutt_window.h:110
@ WT_STATUS_BAR
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:102
@ MUTT_WIN_ORIENT_VERTICAL
Window uses all available vertical space.
Definition: mutt_window.h:38
#define WA_REPAINT
Redraw the contents of the Window.
Definition: mutt_window.h:111
#define MUTT_WIN_SIZE_UNLIMITED
Use as much space as possible.
Definition: mutt_window.h:52
@ MUTT_WIN_SIZE_FIXED
Window has a fixed size.
Definition: mutt_window.h:47
void mutt_str_pretty_size(char *buf, size_t buflen, size_t num)
Display an abbreviated size, like 3.4K.
Definition: muttlib.c:1066
Some miscellaneous functions.
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
struct ProgressWindowData * progress_wdata_new(void)
Create new Progress Bar Window Data.
Definition: wdata.c:37
Progress Bar Window Data.
void progress_window_set_size(struct MuttWindow *win, size_t size)
Set the progress size.
Definition: window.c:363
static bool percent_needs_update(const struct ProgressWindowData *wdata, int percent)
Do we need to update, given the current percentage?
Definition: window.c:232
bool progress_window_update(struct MuttWindow *win, size_t pos, int percent)
Update the Progress Bar Window.
Definition: window.c:274
void progress_window_set_message(struct MuttWindow *win, const char *fmt, va_list ap)
Set the progress message.
Definition: window.c:346
static void message_bar(struct MuttWindow *win, int percent, const char *fmt,...)
Draw a colourful progress bar.
Definition: window.c:75
static bool time_needs_update(const struct ProgressWindowData *wdata, size_t now)
Do we need to update, given the current time?
Definition: window.c:255
static bool pos_needs_update(const struct ProgressWindowData *wdata, long pos)
Do we need to update, given the current pos?
Definition: window.c:243
struct MuttWindow * progress_window_new(size_t size, size_t size_inc, size_t time_inc, bool is_bytes)
Create a new Progress Bar Window.
Definition: window.c:311
String manipulation buffer.
Definition: buffer.h:36
size_t dsize
Length of data.
Definition: buffer.h:39
char * data
Pointer to data.
Definition: buffer.h:37
int(* repaint)(struct MuttWindow *win)
Definition: mutt_window.h:187
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
void * wdata
Private data.
Definition: mutt_window.h:145
int(* recalc)(struct MuttWindow *win)
Definition: mutt_window.h:173
void(* wdata_free)(struct MuttWindow *win, void **ptr)
Definition: mutt_window.h:159
WindowActionFlags actions
Actions to be performed, e.g. WA_RECALC.
Definition: mutt_window.h:132
enum MuttWindowSize size
Type of Window, e.g. MUTT_WIN_SIZE_FIXED.
Definition: mutt_window.h:131
Progress Bar Window Data.
Definition: wdata.h:36
int update_percent
Updated percentage complete.
Definition: wdata.h:55
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
size_t time_inc
Time increment.
Definition: wdata.h:44
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
size_t size_inc
Size increment.
Definition: wdata.h:43
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
char pretty_size[24]
Pretty string for size.
Definition: wdata.h:41
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60