NeoMutt  2022-04-29-247-gc6aae8
Teaching an old dog new tricks
DOXYGEN
mutt_window.c
Go to the documentation of this file.
1
29#include "config.h"
30#include <stdarg.h>
31#include <string.h>
32#include "mutt/lib.h"
33#include "config/lib.h"
34#include "mutt_window.h"
35#include "curs_lib.h"
36#include "mutt_curses.h"
37#include "mutt_globals.h"
38#include "options.h"
39#include "reflow.h"
40#include "rootwin.h"
41#ifdef USE_DEBUG_WINDOW
42#include "debug/lib.h"
43#endif
44
46static const struct Mapping WindowNames[] = {
47 // clang-format off
48 { "WT_ALL_DIALOGS", WT_ALL_DIALOGS },
49 { "WT_CONTAINER", WT_CONTAINER },
50 { "WT_CUSTOM", WT_CUSTOM },
51 { "WT_DLG_ALIAS", WT_DLG_ALIAS },
52 { "WT_DLG_ATTACH", WT_DLG_ATTACH },
53 { "WT_DLG_AUTOCRYPT", WT_DLG_AUTOCRYPT },
54 { "WT_DLG_BROWSER", WT_DLG_BROWSER },
55 { "WT_DLG_CERTIFICATE", WT_DLG_CERTIFICATE },
56 { "WT_DLG_COMPOSE", WT_DLG_COMPOSE },
57 { "WT_DLG_CRYPT_GPGME", WT_DLG_CRYPT_GPGME },
58 { "WT_DLG_DO_PAGER", WT_DLG_DO_PAGER },
59 { "WT_DLG_HISTORY", WT_DLG_HISTORY },
60 { "WT_DLG_INDEX", WT_DLG_INDEX },
61 { "WT_DLG_PGP", WT_DLG_PGP },
62 { "WT_DLG_POSTPONE", WT_DLG_POSTPONE },
63 { "WT_DLG_QUERY", WT_DLG_QUERY },
64 { "WT_DLG_REMAILER", WT_DLG_REMAILER },
65 { "WT_DLG_SMIME", WT_DLG_SMIME },
66 { "WT_HELP_BAR", WT_HELP_BAR },
67 { "WT_INDEX", WT_INDEX },
68 { "WT_MENU", WT_MENU },
69 { "WT_MESSAGE", WT_MESSAGE },
70 { "WT_PAGER", WT_PAGER },
71 { "WT_ROOT", WT_ROOT },
72 { "WT_SIDEBAR", WT_SIDEBAR },
73 { "WT_STATUS_BAR", WT_STATUS_BAR },
74 { NULL, 0 },
75 // clang-format on
76};
77
87static bool window_was_visible(struct MuttWindow *win)
88{
89 if (!win)
90 return false;
91
92 for (; win; win = win->parent)
93 {
94 if (!win->old.visible)
95 return false;
96 }
97
98 return true;
99}
100
105static void window_notify(struct MuttWindow *win)
106{
107 if (!win->notify)
108 return;
109
110 const struct WindowState *old = &win->old;
111 const struct WindowState *state = &win->state;
113
114 const bool was_visible = window_was_visible(win);
115 const bool is_visible = mutt_window_is_visible(win);
116 if (was_visible != is_visible)
117 flags |= is_visible ? WN_VISIBLE : WN_HIDDEN;
118
119 if ((state->row_offset != old->row_offset) || (state->col_offset != old->col_offset))
120 flags |= WN_MOVED;
121
122 if (state->rows > old->rows)
123 flags |= WN_TALLER;
124 else if (state->rows < old->rows)
125 flags |= WN_SHORTER;
126
127 if (state->cols > old->cols)
128 flags |= WN_WIDER;
129 else if (state->cols < old->cols)
130 flags |= WN_NARROWER;
131
132 if (flags == WN_NO_FLAGS)
133 return;
134
135 mutt_debug(LL_NOTIFY, "NT_WINDOW_STATE: %s, %p\n", mutt_window_win_name(win), win);
136 struct EventWindow ev_w = { win, flags };
138}
139
145{
146 if (!win)
147 win = RootWindow;
148
150
151 struct MuttWindow *np = NULL;
152 TAILQ_FOREACH(np, &win->children, entries)
153 {
155 }
156 win->old = win->state;
157}
158
164void window_set_visible(struct MuttWindow *win, bool visible)
165{
166 if (!win)
167 win = RootWindow;
168
169 win->state.visible = visible;
170}
171
182 enum MuttWindowSize size, int cols, int rows)
183{
184 struct MuttWindow *win = mutt_mem_calloc(1, sizeof(struct MuttWindow));
185
186 win->type = type;
187 win->orient = orient;
188 win->size = size;
189 win->req_rows = rows;
190 win->req_cols = cols;
191 win->state.visible = true;
192 win->notify = notify_new();
193 TAILQ_INIT(&win->children);
194 return win;
195}
196
201void mutt_window_free(struct MuttWindow **ptr)
202{
203 if (!ptr || !*ptr)
204 return;
205
206 struct MuttWindow *win = *ptr;
207
208 if (win->parent && (win->parent->focus == win))
209 win->parent->focus = NULL;
210
211 mutt_debug(LL_NOTIFY, "NT_WINDOW_DELETE: %s, %p\n", mutt_window_win_name(win), win);
212 struct EventWindow ev_w = { win, WN_NO_FLAGS };
214
216
217 if (win->wdata_free && win->wdata)
218 win->wdata_free(win, &win->wdata); // Custom function to free private data
219
221
222 FREE(ptr);
223}
224
231{
232 mutt_window_move(win, 0, row);
234}
235
243{
244 if (!win || !stdscr)
245 return;
246
247 if ((win->state.col_offset + win->state.cols) == COLS)
248 clrtoeol();
249 else
250 {
251 int row = 0;
252 int col = 0;
253 getyx(stdscr, row, col);
254 int curcol = col;
255 while (curcol < (win->state.col_offset + win->state.cols))
256 {
257 addch(' ');
258 curcol++;
259 }
260 move(row, col);
261 }
262}
263
273void mutt_window_get_coords(struct MuttWindow *win, int *col, int *row)
274{
275 int x = 0;
276 int y = 0;
277
278 getyx(stdscr, y, x);
279 if (col)
280 *col = x - win->state.col_offset;
281 if (row)
282 *row = y - win->state.row_offset;
283}
284
293int mutt_window_move(struct MuttWindow *win, int col, int row)
294{
295 return move(win->state.row_offset + row, win->state.col_offset + col);
296}
297
307int mutt_window_mvaddstr(struct MuttWindow *win, int col, int row, const char *str)
308{
309 return mvaddstr(win->state.row_offset + row, win->state.col_offset + col, str);
310}
311
322int mutt_window_mvprintw(struct MuttWindow *win, int col, int row, const char *fmt, ...)
323{
324 int rc = mutt_window_move(win, col, row);
325 if (rc == ERR)
326 return rc;
327
328 va_list ap;
329 va_start(ap, fmt);
330 rc = vw_printw(stdscr, fmt, ap);
331 va_end(ap);
332
333 return rc;
334}
335
341{
342 if (OptNoCurses)
343 return;
344
345 if (!win)
346 win = RootWindow;
347
348 mutt_debug(LL_DEBUG2, "entering\n");
351
352#ifdef USE_DEBUG_WINDOW
354#endif
355}
356
365int mutt_window_wrap_cols(int width, short wrap)
366{
367 if (wrap < 0)
368 return (width > -wrap) ? (width + wrap) : width;
369 if (wrap)
370 return (wrap < width) ? wrap : width;
371 return width;
372}
373
381int mutt_window_addch(struct MuttWindow *win, int ch)
382{
383 return addch(ch);
384}
385
394int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
395{
396 if (!str)
397 return -1;
398
399 return addnstr(str, num);
400}
401
409int mutt_window_addstr(struct MuttWindow *win, const char *str)
410{
411 if (!str)
412 return -1;
413
414 return addstr(str);
415}
416
424int mutt_window_printf(struct MuttWindow *win, const char *fmt, ...)
425{
426 va_list ap;
427 va_start(ap, fmt);
428 int rc = vw_printw(stdscr, fmt, ap);
429 va_end(ap);
430
431 return rc;
432}
433
439void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
440{
441 if (!parent || !child)
442 return;
443
444 TAILQ_INSERT_TAIL(&parent->children, child, entries);
445 child->parent = parent;
446
447 notify_set_parent(child->notify, parent->notify);
448
449 mutt_debug(LL_NOTIFY, "NT_WINDOW_NEW: %s, %p\n", mutt_window_win_name(child), child);
450 struct EventWindow ev_w = { child, WN_NO_FLAGS };
451 notify_send(child->notify, NT_WINDOW, NT_WINDOW_ADD, &ev_w);
452}
453
461{
462 if (!parent || !child)
463 return NULL;
464
465 // A notification will be sent when the Window is freed
466 TAILQ_REMOVE(&parent->children, child, entries);
467 child->parent = NULL;
468
469 notify_set_parent(child->notify, NULL);
470
471 return child;
472}
473
478void mutt_winlist_free(struct MuttWindowList *head)
479{
480 if (!head)
481 return;
482
483 struct MuttWindow *np = NULL;
484 struct MuttWindow *tmp = NULL;
485 TAILQ_FOREACH_SAFE(np, head, entries, tmp)
486 {
487 TAILQ_REMOVE(head, np, entries);
489 mutt_window_free(&np);
490 }
491}
492
502{
503 if (!win)
504 return false;
505
506 for (; win; win = win->parent)
507 {
508 if (!win->state.visible)
509 return false;
510 }
511
512 return true;
513}
514
523{
524 if (!win)
525 return NULL;
526 if (win->type == type)
527 return win;
528
529 struct MuttWindow *np = NULL;
530 struct MuttWindow *match = NULL;
531 TAILQ_FOREACH(np, &win->children, entries)
532 {
533 match = window_find_child(np, type);
534 if (match)
535 return match;
536 }
537
538 return NULL;
539}
540
548{
549 for (; win; win = win->parent)
550 {
551 if (win->type == type)
552 return win;
553 }
554
555 return NULL;
556}
557
562static void window_recalc(struct MuttWindow *win)
563{
564 if (!win || !win->state.visible)
565 return;
566
567 if (win->recalc && (win->actions & WA_RECALC))
568 win->recalc(win);
569 win->actions &= ~WA_RECALC;
570
571 struct MuttWindow *np = NULL;
572 TAILQ_FOREACH(np, &win->children, entries)
573 {
574 window_recalc(np);
575 }
576}
577
582static void window_repaint(struct MuttWindow *win)
583{
584 if (!win || !win->state.visible)
585 return;
586
587 if (win->repaint && (win->actions & WA_REPAINT))
588 win->repaint(win);
589 win->actions &= ~WA_REPAINT;
590
591 struct MuttWindow *np = NULL;
592 TAILQ_FOREACH(np, &win->children, entries)
593 {
594 window_repaint(np);
595 }
596}
597
604void window_redraw(struct MuttWindow *win)
605{
606 if (!win)
607 win = RootWindow;
608
609 if (SigWinch)
610 {
611 SigWinch = false;
614 }
615
616 window_reflow(win);
618
619 window_recalc(win);
620 window_repaint(win);
621 mutt_refresh();
622}
623
629bool window_is_focused(const struct MuttWindow *win)
630{
631 if (!win)
632 return false;
633
635
636 return (win_focus == win);
637}
638
644{
645 struct MuttWindow *win = RootWindow;
646
647 while (win && win->focus)
648 win = win->focus;
649
650 return win;
651}
652
660{
661 if (!win)
662 return NULL;
663
664 struct MuttWindow *old_focus = window_get_focus();
665
666 struct MuttWindow *parent = win->parent;
667 struct MuttWindow *child = win;
668
669 // Set the chain of focus, all the way to the root
670 for (; parent; child = parent, parent = parent->parent)
671 parent->focus = child;
672
673 // Find the most focused Window
674 while (win && win->focus)
675 win = win->focus;
676
677 if (win == old_focus)
678 return NULL;
679
680 mutt_debug(LL_NOTIFY, "NT_WINDOW_FOCUS: %s, %p\n", mutt_window_win_name(win), win);
681 struct EventWindow ev_w = { win, WN_NO_FLAGS };
683#ifdef USE_DEBUG_WINDOW
685#endif
686 return old_focus;
687}
688
696{
698 return;
699
700 for (int i = 0; i < win->state.rows; i++)
702}
703
710const char *mutt_window_win_name(const struct MuttWindow *win)
711{
712 if (!win)
713 return "UNKNOWN";
714
715 const char *name = mutt_map_get_name(win->type, WindowNames);
716 if (name)
717 return name;
718 return "UNKNOWN";
719}
720
725static void window_invalidate(struct MuttWindow *win)
726{
727 if (!win)
728 return;
729
731
732 struct MuttWindow *np = NULL;
733 TAILQ_FOREACH(np, &win->children, entries)
734 {
736 }
737}
738
743{
745 clearok(stdscr, true);
746 keypad(stdscr, true);
747}
748
759bool window_status_on_top(struct MuttWindow *panel, struct ConfigSubset *sub)
760{
761 const bool c_status_on_top = cs_subset_bool(sub, "status_on_top");
762
763 struct MuttWindow *win = TAILQ_FIRST(&panel->children);
764
765 if ((c_status_on_top && (win->type == WT_STATUS_BAR)) ||
766 (!c_status_on_top && (win->type != WT_STATUS_BAR)))
767 {
768 return false;
769 }
770
771 if (c_status_on_top)
772 {
773 win = TAILQ_LAST(&panel->children, MuttWindowList);
774 TAILQ_REMOVE(&panel->children, win, entries);
775 TAILQ_INSERT_HEAD(&panel->children, win, entries);
776 }
777 else
778 {
779 TAILQ_REMOVE(&panel->children, win, entries);
780 TAILQ_INSERT_TAIL(&panel->children, win, entries);
781 }
782
783 mutt_window_reflow(panel);
785 return true;
786}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
Convenience wrapper for the config headers.
void mutt_refresh(void)
Force a refresh of the screen.
Definition: curs_lib.c:140
GUI miscellaneous curses (window drawing) routines.
Convenience wrapper for the debug headers.
void debug_win_dump(void)
Definition: window.c:95
static struct MuttWindow * win_focus
Definition: window.c:38
#define mutt_debug(LEVEL,...)
Definition: logging.h:84
@ LL_DEBUG2
Log at debug level 2.
Definition: logging.h:41
@ LL_NOTIFY
Log of notifications.
Definition: logging.h:45
const char * mutt_map_get_name(int val, const struct Mapping *map)
Lookup a string for a constant.
Definition: mapping.c:42
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
#define FREE(x)
Definition: memory.h:43
Convenience wrapper for the library headers.
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:60
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:171
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:93
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:73
Define wrapper functions around Curses.
void mutt_resize_screen(void)
Update NeoMutt's opinion about the window size (CURSES)
Definition: resize.c:73
Hundreds of global variables to back the user variables.
SIG_ATOMIC_VOLATILE_T SigWinch
true after SIGWINCH is received
Definition: mutt_globals.h:70
static bool is_visible(struct Email *e)
Is the message visible?
Definition: mutt_thread.c:131
void mutt_window_clear(struct MuttWindow *win)
Clear a Window.
Definition: mutt_window.c:695
bool mutt_window_is_visible(struct MuttWindow *win)
Is the Window visible?
Definition: mutt_window.c:501
void window_redraw(struct MuttWindow *win)
Reflow, recalc and repaint a tree of Windows.
Definition: mutt_window.c:604
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:340
struct MuttWindow * window_find_parent(struct MuttWindow *win, enum WindowType type)
Find a (grand-)parent of a Window by type.
Definition: mutt_window.c:547
void window_notify_all(struct MuttWindow *win)
Notify observers of changes to a Window and its children.
Definition: mutt_window.c:144
bool window_status_on_top(struct MuttWindow *panel, struct ConfigSubset *sub)
Organise windows according to config variable.
Definition: mutt_window.c:759
static void window_notify(struct MuttWindow *win)
Notify observers of changes to a Window.
Definition: mutt_window.c:105
bool window_is_focused(const struct MuttWindow *win)
Does the given Window have the focus?
Definition: mutt_window.c:629
static const struct Mapping WindowNames[]
Lookups for Window Names.
Definition: mutt_window.c:46
void mutt_window_free(struct MuttWindow **ptr)
Free a Window and its children.
Definition: mutt_window.c:201
void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
Add a child to Window.
Definition: mutt_window.c:439
const char * mutt_window_win_name(const struct MuttWindow *win)
Get the name of a Window.
Definition: mutt_window.c:710
int mutt_window_printf(struct MuttWindow *win, const char *fmt,...)
Write a formatted string to a Window.
Definition: mutt_window.c:424
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:181
struct MuttWindow * window_get_focus(void)
Get the currently focused Window.
Definition: mutt_window.c:643
static void window_invalidate(struct MuttWindow *win)
Mark a window as in need of repaint.
Definition: mutt_window.c:725
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:293
static void window_recalc(struct MuttWindow *win)
Recalculate a tree of Windows.
Definition: mutt_window.c:562
struct MuttWindow * window_set_focus(struct MuttWindow *win)
Set the Window focus.
Definition: mutt_window.c:659
struct MuttWindow * mutt_window_remove_child(struct MuttWindow *parent, struct MuttWindow *child)
Remove a child from a Window.
Definition: mutt_window.c:460
void window_set_visible(struct MuttWindow *win, bool visible)
Set a Window visible or hidden.
Definition: mutt_window.c:164
static bool window_was_visible(struct MuttWindow *win)
Was the Window visible?
Definition: mutt_window.c:87
void mutt_window_get_coords(struct MuttWindow *win, int *col, int *row)
Get the cursor position in the Window.
Definition: mutt_window.c:273
int mutt_window_wrap_cols(int width, short wrap)
Calculate the wrap column for a given screen width.
Definition: mutt_window.c:365
void mutt_winlist_free(struct MuttWindowList *head)
Free a tree of Windows.
Definition: mutt_window.c:478
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:522
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:307
void mutt_window_clearline(struct MuttWindow *win, int row)
Clear a row of a Window.
Definition: mutt_window.c:230
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition: mutt_window.c:409
int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
Write a partial string to a Window.
Definition: mutt_window.c:394
void mutt_window_clrtoeol(struct MuttWindow *win)
Clear to the end of the line.
Definition: mutt_window.c:242
static void window_repaint(struct MuttWindow *win)
Repaint a tree of Windows.
Definition: mutt_window.c:582
int mutt_window_mvprintw(struct MuttWindow *win, int col, int row, const char *fmt,...)
Move the cursor and write a formatted string to a Window.
Definition: mutt_window.c:322
void window_invalidate_all(void)
Mark all windows as in need of repaint.
Definition: mutt_window.c:742
int mutt_window_addch(struct MuttWindow *win, int ch)
Write one character to a Window.
Definition: mutt_window.c:381
Window management.
#define WA_RECALC
Recalculate the contents of the Window.
Definition: mutt_window.h:110
#define WN_MOVED
Window moved.
Definition: mutt_window.h:191
uint8_t WindowNotifyFlags
Flags for Changes to a MuttWindow, e.g. WN_TALLER.
Definition: mutt_window.h:185
#define WN_WIDER
Window became wider.
Definition: mutt_window.h:189
WindowType
Type of Window.
Definition: mutt_window.h:70
@ WT_DLG_REMAILER
Remailer Dialog, dlg_mixmaster()
Definition: mutt_window.h:91
@ WT_CUSTOM
Window with a custom drawing function.
Definition: mutt_window.h:95
@ WT_ROOT
Parent of All Windows.
Definition: mutt_window.h:72
@ WT_DLG_ALIAS
Alias Dialog, dlg_select_alias()
Definition: mutt_window.h:77
@ WT_ALL_DIALOGS
Container for All Dialogs (nested Windows)
Definition: mutt_window.h:74
@ WT_DLG_BROWSER
Browser Dialog, mutt_buffer_select_file()
Definition: mutt_window.h:80
@ WT_MESSAGE
Window for messages/errors and command entry.
Definition: mutt_window.h:99
@ WT_DLG_SMIME
Smime Dialog, dlg_select_smime_key()
Definition: mutt_window.h:92
@ WT_DLG_QUERY
Query Dialog, dlg_select_query()
Definition: mutt_window.h:90
@ WT_DLG_HISTORY
History Dialog, dlg_select_history()
Definition: mutt_window.h:85
@ WT_DLG_PGP
Pgp Dialog, dlg_select_pgp_key()
Definition: mutt_window.h:88
@ WT_CONTAINER
Invisible shaping container Window.
Definition: mutt_window.h:73
@ WT_DLG_CERTIFICATE
Certificate Dialog, dlg_verify_certificate()
Definition: mutt_window.h:81
@ WT_DLG_COMPOSE
Compose Dialog, mutt_compose_menu()
Definition: mutt_window.h:82
@ WT_DLG_INDEX
Index Dialog, index_pager_init()
Definition: mutt_window.h:86
@ WT_PAGER
A panel containing the Pager Window.
Definition: mutt_window.h:100
@ WT_DLG_CRYPT_GPGME
Crypt-GPGME Dialog, dlg_select_gpgme_key()
Definition: mutt_window.h:83
@ WT_STATUS_BAR
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:102
@ WT_HELP_BAR
Help Bar containing list of useful key bindings.
Definition: mutt_window.h:96
@ WT_DLG_POSTPONE
Postpone Dialog, dlg_select_postponed_email()
Definition: mutt_window.h:89
@ WT_INDEX
A panel containing the Index Window.
Definition: mutt_window.h:97
@ WT_DLG_ATTACH
Attach Dialog, dlg_select_attachment()
Definition: mutt_window.h:78
@ WT_SIDEBAR
Side panel containing Accounts or groups of data.
Definition: mutt_window.h:101
@ WT_DLG_DO_PAGER
Pager Dialog, mutt_do_pager()
Definition: mutt_window.h:84
@ WT_DLG_AUTOCRYPT
Autocrypt Dialog, dlg_select_autocrypt_account()
Definition: mutt_window.h:79
@ WT_MENU
An Window containing a Menu.
Definition: mutt_window.h:98
MuttWindowOrientation
Which way does the Window expand?
Definition: mutt_window.h:37
@ NT_WINDOW_STATE
Window state has changed, e.g. WN_VISIBLE.
Definition: mutt_window.h:207
@ NT_WINDOW_DELETE
Window is about to be deleted.
Definition: mutt_window.h:206
@ NT_WINDOW_FOCUS
Window focus has changed.
Definition: mutt_window.h:209
@ NT_WINDOW_ADD
New Window has been added.
Definition: mutt_window.h:205
#define WN_VISIBLE
Window became visible.
Definition: mutt_window.h:192
#define WN_HIDDEN
Window became hidden.
Definition: mutt_window.h:193
#define WN_NO_FLAGS
No flags are set.
Definition: mutt_window.h:186
#define WA_REPAINT
Redraw the contents of the Window.
Definition: mutt_window.h:111
#define WN_TALLER
Window became taller.
Definition: mutt_window.h:187
MuttWindowSize
Control the allocation of Window space.
Definition: mutt_window.h:46
#define WN_NARROWER
Window became narrower.
Definition: mutt_window.h:190
#define WN_SHORTER
Window became shorter.
Definition: mutt_window.h:188
@ NT_WINDOW
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:55
Handling of global boolean variables.
bool OptNoCurses
(pseudo) when sending in batch mode
Definition: options.h:53
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:735
#define TAILQ_INIT(head)
Definition: queue.h:765
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:809
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:841
#define TAILQ_LAST(head, headname)
Definition: queue.h:819
#define TAILQ_INSERT_HEAD(head, elm, field)
Definition: queue.h:796
void window_reflow(struct MuttWindow *win)
Reflow Windows.
Definition: reflow.c:220
Window management.
struct MuttWindow * RootWindow
Parent of all Windows.
Definition: rootwin.c:104
Root Window.
A set of inherited config items.
Definition: subset.h:47
An Event that happened to a Window.
Definition: mutt_window.h:216
struct MuttWindow * win
Window that changed.
Definition: mutt_window.h:217
WindowNotifyFlags flags
Attributes of Window that changed.
Definition: mutt_window.h:218
Mapping between user-readable string and a constant.
Definition: mapping.h:32
struct WindowState old
Previous state of the Window.
Definition: mutt_window.h:128
int(* repaint)(struct MuttWindow *win)
Definition: mutt_window.h:182
short req_cols
Number of columns required.
Definition: mutt_window.h:124
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
struct MuttWindow * focus
Focused Window.
Definition: mutt_window.h:140
void * wdata
Private data.
Definition: mutt_window.h:145
enum MuttWindowOrientation orient
Which direction the Window will expand.
Definition: mutt_window.h:130
struct Notify * notify
Notifications: NotifyWindow, EventWindow.
Definition: mutt_window.h:138
short req_rows
Number of rows required.
Definition: mutt_window.h:125
int(* recalc)(struct MuttWindow *win)
Definition: mutt_window.h:171
void(* wdata_free)(struct MuttWindow *win, void **ptr)
Definition: mutt_window.h:160
struct MuttWindowList children
Children Windows.
Definition: mutt_window.h:136
struct MuttWindow * parent
Parent Window.
Definition: mutt_window.h:135
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
enum WindowType type
Window type, e.g. WT_SIDEBAR.
Definition: mutt_window.h:144
The current, or old, state of a Window.
Definition: mutt_window.h:58
bool visible
Window is visible.
Definition: mutt_window.h:59
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
short row_offset
Absolute on-screen row.
Definition: mutt_window.h:63
short col_offset
Absolute on-screen column.
Definition: mutt_window.h:62
short rows
Number of rows, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:61