NeoMutt  2024-04-25-127-g771158
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
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 "globals.h"
37#include "mutt_curses.h"
38#include "reflow.h"
39#include "rootwin.h"
40#ifdef USE_DEBUG_WINDOW
41#include "debug/lib.h"
42#endif
43
45static const struct Mapping WindowNames[] = {
46 // clang-format off
47 { "WT_ALL_DIALOGS", WT_ALL_DIALOGS },
48 { "WT_CONTAINER", WT_CONTAINER },
49 { "WT_CUSTOM", WT_CUSTOM },
50 { "WT_DLG_ALIAS", WT_DLG_ALIAS },
51 { "WT_DLG_ATTACHMENT", WT_DLG_ATTACHMENT },
52 { "WT_DLG_AUTOCRYPT", WT_DLG_AUTOCRYPT },
53 { "WT_DLG_BROWSER", WT_DLG_BROWSER },
54 { "WT_DLG_CERTIFICATE", WT_DLG_CERTIFICATE },
55 { "WT_DLG_COMPOSE", WT_DLG_COMPOSE },
56 { "WT_DLG_GPGME", WT_DLG_GPGME },
57 { "WT_DLG_HISTORY", WT_DLG_HISTORY },
58 { "WT_DLG_INDEX", WT_DLG_INDEX },
59 { "WT_DLG_PAGER", WT_DLG_PAGER },
60 { "WT_DLG_PATTERN", WT_DLG_PATTERN },
61 { "WT_DLG_PGP", WT_DLG_PGP },
62 { "WT_DLG_POSTPONED", WT_DLG_POSTPONED },
63 { "WT_DLG_QUERY", WT_DLG_QUERY },
64 { "WT_DLG_SMIME", WT_DLG_SMIME },
65 { "WT_HELP_BAR", WT_HELP_BAR },
66 { "WT_INDEX", WT_INDEX },
67 { "WT_MENU", WT_MENU },
68 { "WT_MESSAGE", WT_MESSAGE },
69 { "WT_PAGER", WT_PAGER },
70 { "WT_ROOT", WT_ROOT },
71 { "WT_SIDEBAR", WT_SIDEBAR },
72 { "WT_STATUS_BAR", WT_STATUS_BAR },
73 { NULL, 0 },
74 // clang-format on
75};
76
86static bool window_was_visible(struct MuttWindow *win)
87{
88 if (!win)
89 return false;
90
91 for (; win; win = win->parent)
92 {
93 if (!win->old.visible)
94 return false;
95 }
96
97 return true;
98}
99
104static void window_notify(struct MuttWindow *win)
105{
106 if (!win->notify)
107 return;
108
109 const struct WindowState *old = &win->old;
110 const struct WindowState *wstate = &win->state;
112
113 const bool was_visible = window_was_visible(win);
114 const bool is_visible = mutt_window_is_visible(win);
115 if (was_visible != is_visible)
116 flags |= is_visible ? WN_VISIBLE : WN_HIDDEN;
117
118 if ((wstate->row_offset != old->row_offset) || (wstate->col_offset != old->col_offset))
119 flags |= WN_MOVED;
120
121 if (wstate->rows > old->rows)
122 flags |= WN_TALLER;
123 else if (wstate->rows < old->rows)
124 flags |= WN_SHORTER;
125
126 if (wstate->cols > old->cols)
127 flags |= WN_WIDER;
128 else if (wstate->cols < old->cols)
129 flags |= WN_NARROWER;
130
131 if (flags == WN_NO_FLAGS)
132 return;
133
134 mutt_debug(LL_NOTIFY, "NT_WINDOW_STATE: %s, %p\n", mutt_window_win_name(win),
135 (void *) 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),
212 (void *) win);
213 struct EventWindow ev_w = { win, WN_NO_FLAGS };
215
217
218 if (win->wdata_free && win->wdata)
219 win->wdata_free(win, &win->wdata); // Custom function to free private data
220
222
223 FREE(ptr);
224}
225
232{
233 mutt_window_move(win, 0, row);
235}
236
244{
245 if (!win || !stdscr)
246 return;
247
248 if ((win->state.col_offset + win->state.cols) == COLS)
249 {
250 clrtoeol();
251 }
252 else
253 {
254 int row = 0;
255 int col = 0;
256 getyx(stdscr, row, col);
257 int curcol = col;
258 while (curcol < (win->state.col_offset + win->state.cols))
259 {
260 addch(' ');
261 curcol++;
262 }
263 move(row, col);
264 }
265}
266
276void mutt_window_get_coords(struct MuttWindow *win, int *col, int *row)
277{
278 int x = 0;
279 int y = 0;
280
281 getyx(stdscr, y, x);
282 if (col)
283 *col = x - win->state.col_offset;
284 if (row)
285 *row = y - win->state.row_offset;
286}
287
296int mutt_window_move(struct MuttWindow *win, int col, int row)
297{
298 return move(win->state.row_offset + row, win->state.col_offset + col);
299}
300
310int mutt_window_mvaddstr(struct MuttWindow *win, int col, int row, const char *str)
311{
312 return mvaddstr(win->state.row_offset + row, win->state.col_offset + col, str);
313}
314
325int mutt_window_mvprintw(struct MuttWindow *win, int col, int row, const char *fmt, ...)
326{
327 int rc = mutt_window_move(win, col, row);
328 if (rc == ERR)
329 return rc;
330
331 va_list ap;
332 va_start(ap, fmt);
333 rc = vw_printw(stdscr, fmt, ap);
334 va_end(ap);
335
336 return rc;
337}
338
344{
345 if (OptNoCurses)
346 return;
347
348 if (!win)
349 win = RootWindow;
350
353
354 // Allow Windows to resize themselves based on the first reflow
357
358#ifdef USE_DEBUG_WINDOW
360#endif
361}
362
371int mutt_window_wrap_cols(int width, short wrap)
372{
373 if (wrap < 0)
374 return (width > -wrap) ? (width + wrap) : width;
375 if (wrap)
376 return (wrap < width) ? wrap : width;
377 return width;
378}
379
387int mutt_window_addch(struct MuttWindow *win, int ch)
388{
389 return addch(ch);
390}
391
400int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
401{
402 if (!str)
403 return -1;
404
405 return addnstr(str, num);
406}
407
415int mutt_window_addstr(struct MuttWindow *win, const char *str)
416{
417 if (!str)
418 return -1;
419
420 return addstr(str);
421}
422
430int mutt_window_printf(struct MuttWindow *win, const char *fmt, ...)
431{
432 va_list ap;
433 va_start(ap, fmt);
434 int rc = vw_printw(stdscr, fmt, ap);
435 va_end(ap);
436
437 return rc;
438}
439
445void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
446{
447 if (!parent || !child)
448 return;
449
450 TAILQ_INSERT_TAIL(&parent->children, child, entries);
451 child->parent = parent;
452
453 notify_set_parent(child->notify, parent->notify);
454
455 mutt_debug(LL_NOTIFY, "NT_WINDOW_NEW: %s, %p\n", mutt_window_win_name(child),
456 (void *) child);
457 struct EventWindow ev_w = { child, WN_NO_FLAGS };
458 notify_send(child->notify, NT_WINDOW, NT_WINDOW_ADD, &ev_w);
459}
460
468{
469 if (!parent || !child)
470 return NULL;
471
472 // A notification will be sent when the Window is freed
473 TAILQ_REMOVE(&parent->children, child, entries);
474 child->parent = NULL;
475
476 if (parent->focus == child)
477 parent->focus = NULL;
478
479 notify_set_parent(child->notify, NULL);
480
481 return child;
482}
483
488void mutt_winlist_free(struct MuttWindowList *head)
489{
490 if (!head)
491 return;
492
493 struct MuttWindow *np = NULL;
494 struct MuttWindow *tmp = NULL;
495 TAILQ_FOREACH_SAFE(np, head, entries, tmp)
496 {
497 TAILQ_REMOVE(head, np, entries);
499 mutt_window_free(&np);
500 }
501}
502
512{
513 if (!win)
514 return false;
515
516 for (; win; win = win->parent)
517 {
518 if (!win->state.visible)
519 return false;
520 }
521
522 return true;
523}
524
533{
534 if (!win)
535 return NULL;
536 if (win->type == type)
537 return win;
538
539 struct MuttWindow *np = NULL;
540 struct MuttWindow *match = NULL;
541 TAILQ_FOREACH(np, &win->children, entries)
542 {
543 match = window_find_child(np, type);
544 if (match)
545 return match;
546 }
547
548 return NULL;
549}
550
558{
559 for (; win; win = win->parent)
560 {
561 if (win->type == type)
562 return win;
563 }
564
565 return NULL;
566}
567
572static void window_recalc(struct MuttWindow *win)
573{
574 if (!win || !win->state.visible)
575 return;
576
577 if (win->recalc && (win->actions & WA_RECALC))
578 win->recalc(win);
579 win->actions &= ~WA_RECALC;
580
581 struct MuttWindow *np = NULL;
582 TAILQ_FOREACH(np, &win->children, entries)
583 {
584 window_recalc(np);
585 }
586}
587
592static void window_repaint(struct MuttWindow *win)
593{
594 if (!win || !win->state.visible)
595 return;
596
597 if (win->repaint && (win->actions & WA_REPAINT))
598 win->repaint(win);
599 win->actions &= ~WA_REPAINT;
600
601 struct MuttWindow *np = NULL;
602 TAILQ_FOREACH(np, &win->children, entries)
603 {
604 window_repaint(np);
605 }
606}
607
614static void window_recursor(void)
615{
616 // Give the focussed window an opportunity to set the cursor position
617 struct MuttWindow *win = window_get_focus();
618 if (!win)
619 return;
620
621 if (win->recursor && win->recursor(win))
622 return;
623
625}
626
633void window_redraw(struct MuttWindow *win)
634{
635 if (!win)
636 win = RootWindow;
637
638 window_reflow(win);
640
641 window_recalc(win);
642 window_repaint(win);
644
645 mutt_refresh();
646}
647
653bool window_is_focused(const struct MuttWindow *win)
654{
655 if (!win)
656 return false;
657
658 struct MuttWindow *win_focus = window_get_focus();
659
660 return (win_focus == win);
661}
662
668{
669 struct MuttWindow *win = RootWindow;
670
671 while (win && win->focus)
672 win = win->focus;
673
674 return win;
675}
676
684{
685 if (!win)
686 return NULL;
687
688 struct MuttWindow *old_focus = window_get_focus();
689
690 struct MuttWindow *parent = win->parent;
691 struct MuttWindow *child = win;
692
693 // Set the chain of focus, all the way to the root
694 for (; parent; child = parent, parent = parent->parent)
695 parent->focus = child;
696
697 win->focus = NULL;
698
699 if (win == old_focus)
700 return NULL;
701
702 mutt_debug(LL_NOTIFY, "NT_WINDOW_FOCUS: %s, %p\n", mutt_window_win_name(win),
703 (void *) win);
704 struct EventWindow ev_w = { win, WN_NO_FLAGS };
706#ifdef USE_DEBUG_WINDOW
708#endif
709
710 return old_focus;
711}
712
720{
722 return;
723
724 for (int i = 0; i < win->state.rows; i++)
726}
727
734const char *mutt_window_win_name(const struct MuttWindow *win)
735{
736 if (!win)
737 return "UNKNOWN";
738
739 const char *name = mutt_map_get_name(win->type, WindowNames);
740 if (name)
741 return name;
742 return "UNKNOWN";
743}
744
749static void window_invalidate(struct MuttWindow *win)
750{
751 if (!win)
752 return;
753
755
756 struct MuttWindow *np = NULL;
757 TAILQ_FOREACH(np, &win->children, entries)
758 {
760 }
761}
762
767{
769 clearok(stdscr, true);
770 keypad(stdscr, true);
771}
772
783bool window_status_on_top(struct MuttWindow *panel, struct ConfigSubset *sub)
784{
785 const bool c_status_on_top = cs_subset_bool(sub, "status_on_top");
786
787 struct MuttWindow *win = TAILQ_FIRST(&panel->children);
788
789 if ((c_status_on_top && (win->type == WT_STATUS_BAR)) ||
790 (!c_status_on_top && (win->type != WT_STATUS_BAR)))
791 {
792 return false;
793 }
794
795 if (c_status_on_top)
796 {
797 win = TAILQ_LAST(&panel->children, MuttWindowList);
798 TAILQ_REMOVE(&panel->children, win, entries);
799 TAILQ_INSERT_HEAD(&panel->children, win, entries);
800 }
801 else
802 {
803 TAILQ_REMOVE(&panel->children, win, entries);
804 TAILQ_INSERT_TAIL(&panel->children, win, entries);
805 }
806
807 mutt_window_reflow(panel);
809 return true;
810}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
Convenience wrapper for the config headers.
void mutt_refresh(void)
Force a refresh of the screen.
Definition: curs_lib.c:78
GUI miscellaneous curses (window drawing) routines.
Convenience wrapper for the debug headers.
void debug_win_dump(void)
Definition: window.c:96
bool OptNoCurses
(pseudo) when sending in batch mode
Definition: globals.c:70
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ LL_NOTIFY
Log of notifications.
Definition: logging2.h:48
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:51
#define FREE(x)
Definition: memory.h:45
Convenience wrapper for the library headers.
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:62
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:173
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:95
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:75
enum MuttCursorState mutt_curses_set_cursor(enum MuttCursorState state)
Set the cursor state.
Definition: mutt_curses.c:94
Define wrapper functions around Curses.
@ MUTT_CURSOR_INVISIBLE
Hide the cursor.
Definition: mutt_curses.h:65
static bool is_visible(struct Email *e)
Is the message visible?
Definition: mutt_thread.c:124
void mutt_window_clear(struct MuttWindow *win)
Clear a Window.
Definition: mutt_window.c:719
bool mutt_window_is_visible(struct MuttWindow *win)
Is the Window visible?
Definition: mutt_window.c:511
void window_redraw(struct MuttWindow *win)
Reflow, recalc and repaint a tree of Windows.
Definition: mutt_window.c:633
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:343
static void window_recursor(void)
Recursor the focussed Window.
Definition: mutt_window.c:614
struct MuttWindow * window_find_parent(struct MuttWindow *win, enum WindowType type)
Find a (grand-)parent of a Window by type.
Definition: mutt_window.c:557
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:783
static void window_notify(struct MuttWindow *win)
Notify observers of changes to a Window.
Definition: mutt_window.c:104
bool window_is_focused(const struct MuttWindow *win)
Does the given Window have the focus?
Definition: mutt_window.c:653
static const struct Mapping WindowNames[]
Lookups for Window Names.
Definition: mutt_window.c:45
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:445
const char * mutt_window_win_name(const struct MuttWindow *win)
Get the name of a Window.
Definition: mutt_window.c:734
int mutt_window_printf(struct MuttWindow *win, const char *fmt,...)
Write a formatted string to a Window.
Definition: mutt_window.c:430
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:667
static void window_invalidate(struct MuttWindow *win)
Mark a window as in need of repaint.
Definition: mutt_window.c:749
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:296
static void window_recalc(struct MuttWindow *win)
Recalculate a tree of Windows.
Definition: mutt_window.c:572
struct MuttWindow * window_set_focus(struct MuttWindow *win)
Set the Window focus.
Definition: mutt_window.c:683
struct MuttWindow * mutt_window_remove_child(struct MuttWindow *parent, struct MuttWindow *child)
Remove a child from a Window.
Definition: mutt_window.c:467
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:86
void mutt_window_get_coords(struct MuttWindow *win, int *col, int *row)
Get the cursor position in the Window.
Definition: mutt_window.c:276
int mutt_window_wrap_cols(int width, short wrap)
Calculate the wrap column for a given screen width.
Definition: mutt_window.c:371
void mutt_winlist_free(struct MuttWindowList *head)
Free a tree of Windows.
Definition: mutt_window.c:488
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:532
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:310
void mutt_window_clearline(struct MuttWindow *win, int row)
Clear a row of a Window.
Definition: mutt_window.c:231
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition: mutt_window.c:415
int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
Write a partial string to a Window.
Definition: mutt_window.c:400
void mutt_window_clrtoeol(struct MuttWindow *win)
Clear to the end of the line.
Definition: mutt_window.c:243
static void window_repaint(struct MuttWindow *win)
Repaint a tree of Windows.
Definition: mutt_window.c:592
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:325
void window_invalidate_all(void)
Mark all windows as in need of repaint.
Definition: mutt_window.c:766
int mutt_window_addch(struct MuttWindow *win, int ch)
Write one character to a Window.
Definition: mutt_window.c:387
Window management.
#define WA_RECALC
Recalculate the contents of the Window.
Definition: mutt_window.h:109
#define WN_MOVED
Window moved.
Definition: mutt_window.h:213
uint8_t WindowNotifyFlags
Flags for Changes to a MuttWindow, e.g. WN_TALLER.
Definition: mutt_window.h:207
#define WN_WIDER
Window became wider.
Definition: mutt_window.h:211
WindowType
Type of Window.
Definition: mutt_window.h:70
@ WT_CUSTOM
Window with a custom drawing function.
Definition: mutt_window.h:94
@ WT_ROOT
Parent of All Windows.
Definition: mutt_window.h:72
@ WT_DLG_ALIAS
Alias Dialog, dlg_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, dlg_browser()
Definition: mutt_window.h:80
@ WT_MESSAGE
Window for messages/errors.
Definition: mutt_window.h:98
@ WT_DLG_SMIME
Smime Dialog, dlg_smime()
Definition: mutt_window.h:91
@ WT_DLG_QUERY
Query Dialog, dlg_query()
Definition: mutt_window.h:90
@ WT_DLG_HISTORY
History Dialog, dlg_history()
Definition: mutt_window.h:85
@ WT_DLG_PGP
Pgp Dialog, dlg_pgp()
Definition: mutt_window.h:88
@ WT_CONTAINER
Invisible shaping container Window.
Definition: mutt_window.h:73
@ WT_DLG_CERTIFICATE
Certificate Dialog, dlg_certificate()
Definition: mutt_window.h:81
@ WT_DLG_COMPOSE
Compose Dialog, dlg_compose()
Definition: mutt_window.h:82
@ WT_DLG_INDEX
Index Dialog, dlg_index()
Definition: mutt_window.h:86
@ WT_PAGER
A panel containing the Pager Window.
Definition: mutt_window.h:99
@ WT_DLG_GPGME
GPGME Dialog, dlg_gpgme()
Definition: mutt_window.h:83
@ WT_STATUS_BAR
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:101
@ WT_HELP_BAR
Help Bar containing list of useful key bindings.
Definition: mutt_window.h:95
@ WT_DLG_POSTPONED
Postponed Dialog, dlg_postponed()
Definition: mutt_window.h:89
@ WT_INDEX
A panel containing the Index Window.
Definition: mutt_window.h:96
@ WT_DLG_ATTACHMENT
Attachment Dialog, dlg_attachment()
Definition: mutt_window.h:78
@ WT_SIDEBAR
Side panel containing Accounts or groups of data.
Definition: mutt_window.h:100
@ WT_DLG_PAGER
Pager Dialog, dlg_pager()
Definition: mutt_window.h:84
@ WT_DLG_AUTOCRYPT
Autocrypt Dialog, dlg_autocrypt()
Definition: mutt_window.h:79
@ WT_MENU
An Window containing a Menu.
Definition: mutt_window.h:97
@ WT_DLG_PATTERN
Pattern Dialog, dlg_pattern()
Definition: mutt_window.h:87
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:229
@ NT_WINDOW_DELETE
Window is about to be deleted.
Definition: mutt_window.h:228
@ NT_WINDOW_FOCUS
Window focus has changed.
Definition: mutt_window.h:231
@ NT_WINDOW_ADD
New Window has been added.
Definition: mutt_window.h:227
#define WN_VISIBLE
Window became visible.
Definition: mutt_window.h:214
#define WN_HIDDEN
Window became hidden.
Definition: mutt_window.h:215
#define WN_NO_FLAGS
No flags are set.
Definition: mutt_window.h:208
#define WA_REPAINT
Redraw the contents of the Window.
Definition: mutt_window.h:110
#define WN_TALLER
Window became taller.
Definition: mutt_window.h:209
MuttWindowSize
Control the allocation of Window space.
Definition: mutt_window.h:46
#define WN_NARROWER
Window became narrower.
Definition: mutt_window.h:212
#define WN_SHORTER
Window became shorter.
Definition: mutt_window.h:210
@ NT_WINDOW
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:57
#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:106
Root Window.
A set of inherited config items.
Definition: subset.h:47
An Event that happened to a Window.
Definition: mutt_window.h:238
struct MuttWindow * win
Window that changed.
Definition: mutt_window.h:239
WindowNotifyFlags flags
Attributes of Window that changed.
Definition: mutt_window.h:240
Mapping between user-readable string and a constant.
Definition: mapping.h:33
struct WindowState old
Previous state of the Window.
Definition: mutt_window.h:127
int(* repaint)(struct MuttWindow *win)
Definition: mutt_window.h:186
short req_cols
Number of columns required.
Definition: mutt_window.h:123
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:126
struct MuttWindow * focus
Focused Window.
Definition: mutt_window.h:139
void * wdata
Private data.
Definition: mutt_window.h:144
enum MuttWindowOrientation orient
Which direction the Window will expand.
Definition: mutt_window.h:129
struct Notify * notify
Notifications: NotifyWindow, EventWindow.
Definition: mutt_window.h:137
short req_rows
Number of rows required.
Definition: mutt_window.h:124
int(* recalc)(struct MuttWindow *win)
Definition: mutt_window.h:172
void(* wdata_free)(struct MuttWindow *win, void **ptr)
Definition: mutt_window.h:158
struct MuttWindowList children
Children Windows.
Definition: mutt_window.h:135
struct MuttWindow * parent
Parent Window.
Definition: mutt_window.h:134
WindowActionFlags actions
Actions to be performed, e.g. WA_RECALC.
Definition: mutt_window.h:131
enum MuttWindowSize size
Type of Window, e.g. MUTT_WIN_SIZE_FIXED.
Definition: mutt_window.h:130
bool(* recursor)(struct MuttWindow *win)
Definition: mutt_window.h:204
enum WindowType type
Window type, e.g. WT_SIDEBAR.
Definition: mutt_window.h:143
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