NeoMutt  2021-02-05-666-ge300cd
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 "options.h"
38 #include "reflow.h"
39 #include "rootwin.h"
40 #ifdef USE_DEBUG_WINDOW
41 #include "debug/lib.h"
42 #endif
43 
45 static 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_ATTACH", WT_DLG_ATTACH },
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_CRYPT_GPGME", WT_DLG_CRYPT_GPGME },
57  { "WT_DLG_DO_PAGER", WT_DLG_DO_PAGER },
58  { "WT_DLG_HISTORY", WT_DLG_HISTORY },
59  { "WT_DLG_INDEX", WT_DLG_INDEX },
60  { "WT_DLG_PGP", WT_DLG_PGP },
61  { "WT_DLG_POSTPONE", WT_DLG_POSTPONE },
62  { "WT_DLG_QUERY", WT_DLG_QUERY },
63  { "WT_DLG_REMAILER", WT_DLG_REMAILER },
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  // clang-format off
74  { NULL, 0 },
75 };
76 
86 static 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 
104 static 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 *state = &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 ((state->row_offset != old->row_offset) || (state->col_offset != old->col_offset))
119  flags |= WN_MOVED;
120 
121  if (state->rows > old->rows)
122  flags |= WN_TALLER;
123  else if (state->rows < old->rows)
124  flags |= WN_SHORTER;
125 
126  if (state->cols > old->cols)
127  flags |= WN_WIDER;
128  else if (state->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), win);
135  struct EventWindow ev_w = { win, flags };
137 }
138 
144 {
145  if (!win)
146  win = RootWindow;
147 
148  window_notify(win);
149 
150  struct MuttWindow *np = NULL;
151  TAILQ_FOREACH(np, &win->children, entries)
152  {
153  window_notify_all(np);
154  }
155  win->old = win->state;
156 }
157 
163 void window_set_visible(struct MuttWindow *win, bool visible)
164 {
165  if (!win)
166  win = RootWindow;
167 
168  win->state.visible = visible;
169 }
170 
181  enum MuttWindowSize size, int cols, int rows)
182 {
183  struct MuttWindow *win = mutt_mem_calloc(1, sizeof(struct MuttWindow));
184 
185  win->type = type;
186  win->orient = orient;
187  win->size = size;
188  win->req_rows = rows;
189  win->req_cols = cols;
190  win->state.visible = true;
191  win->notify = notify_new();
192  TAILQ_INIT(&win->children);
193  return win;
194 }
195 
200 void mutt_window_free(struct MuttWindow **ptr)
201 {
202  if (!ptr || !*ptr)
203  return;
204 
205  struct MuttWindow *win = *ptr;
206 
207  if (win->parent && (win->parent->focus == win))
208  win->parent->focus = NULL;
209 
210  mutt_debug(LL_NOTIFY, "NT_WINDOW_DELETE: %s, %p\n", mutt_window_win_name(win), win);
211  struct EventWindow ev_w = { win, WN_NO_FLAGS };
213 
215 
216  if (win->wdata_free && win->wdata)
217  win->wdata_free(win, &win->wdata); // Custom function to free private data
218 
219  notify_free(&win->notify);
220 
221  FREE(ptr);
222 }
223 
224 #ifdef USE_SLANG_CURSES
225 
232 static int vw_printw(SLcurses_Window_Type *win, const char *fmt, va_list ap)
233 {
234  char buf[1024];
235 
236  (void) SLvsnprintf(buf, sizeof(buf), (char *) fmt, ap);
237  SLcurses_waddnstr(win, buf, -1);
238  return 0;
239 }
240 #endif
241 
247 void mutt_window_clearline(struct MuttWindow *win, int row)
248 {
249  mutt_window_move(win, 0, row);
251 }
252 
260 {
261  if (!win || !stdscr)
262  return;
263 
264  if ((win->state.col_offset + win->state.cols) == COLS)
265  clrtoeol();
266  else
267  {
268  int row = 0;
269  int col = 0;
270  getyx(stdscr, row, col);
271  int curcol = col;
272  while (curcol < (win->state.col_offset + win->state.cols))
273  {
274  addch(' ');
275  curcol++;
276  }
277  move(row, col);
278  }
279 }
280 
290 void mutt_window_get_coords(struct MuttWindow *win, int *col, int *row)
291 {
292  int x = 0;
293  int y = 0;
294 
295  getyx(stdscr, y, x);
296  if (col)
297  *col = x - win->state.col_offset;
298  if (row)
299  *row = y - win->state.row_offset;
300 }
301 
310 int mutt_window_move(struct MuttWindow *win, int col, int row)
311 {
312  return move(win->state.row_offset + row, win->state.col_offset + col);
313 }
314 
324 int mutt_window_mvaddstr(struct MuttWindow *win, int col, int row, const char *str)
325 {
326 #ifdef USE_SLANG_CURSES
327  return mvaddstr(win->state.row_offset + row, win->state.col_offset + col, (char *) str);
328 #else
329  return mvaddstr(win->state.row_offset + row, win->state.col_offset + col, str);
330 #endif
331 }
332 
343 int mutt_window_mvprintw(struct MuttWindow *win, int col, int row, const char *fmt, ...)
344 {
345  int rc = mutt_window_move(win, col, row);
346  if (rc == ERR)
347  return rc;
348 
349  va_list ap;
350  va_start(ap, fmt);
351  rc = vw_printw(stdscr, fmt, ap);
352  va_end(ap);
353 
354  return rc;
355 }
356 
362 {
363  if (OptNoCurses)
364  return;
365 
366  if (!win)
367  win = RootWindow;
368 
369  mutt_debug(LL_DEBUG2, "entering\n");
370  window_reflow(win);
371  window_notify_all(win);
372 
373 #ifdef USE_DEBUG_WINDOW
374  debug_win_dump();
375 #endif
376 }
377 
386 int mutt_window_wrap_cols(int width, short wrap)
387 {
388  if (wrap < 0)
389  return (width > -wrap) ? (width + wrap) : width;
390  if (wrap)
391  return (wrap < width) ? wrap : width;
392  return width;
393 }
394 
402 int mutt_window_addch(struct MuttWindow *win, int ch)
403 {
404  return addch(ch);
405 }
406 
415 int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
416 {
417  if (!str)
418  return -1;
419 
420 #ifdef USE_SLANG_CURSES
421  return addnstr((char *) str, num);
422 #else
423  return addnstr(str, num);
424 #endif
425 }
426 
434 int mutt_window_addstr(struct MuttWindow *win, const char *str)
435 {
436  if (!str)
437  return -1;
438 
439 #ifdef USE_SLANG_CURSES
440  return addstr((char *) str);
441 #else
442  return addstr(str);
443 #endif
444 }
445 
453 int mutt_window_printf(struct MuttWindow *win, const char *fmt, ...)
454 {
455  va_list ap;
456  va_start(ap, fmt);
457  int rc = vw_printw(stdscr, fmt, ap);
458  va_end(ap);
459 
460  return rc;
461 }
462 
468 void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
469 {
470  if (!parent || !child)
471  return;
472 
473  TAILQ_INSERT_TAIL(&parent->children, child, entries);
474  child->parent = parent;
475 
476  notify_set_parent(child->notify, parent->notify);
477 
478  mutt_debug(LL_NOTIFY, "NT_WINDOW_NEW: %s, %p\n", mutt_window_win_name(child), child);
479  struct EventWindow ev_w = { child, WN_NO_FLAGS };
480  notify_send(child->notify, NT_WINDOW, NT_WINDOW_ADD, &ev_w);
481 }
482 
489 {
490  if (!parent || !child)
491  return NULL;
492 
493  // A notification will be sent when the Window is freed
494  TAILQ_REMOVE(&parent->children, child, entries);
495  child->parent = NULL;
496 
497  notify_set_parent(child->notify, NULL);
498 
499  return child;
500 }
501 
506 void mutt_winlist_free(struct MuttWindowList *head)
507 {
508  if (!head)
509  return;
510 
511  struct MuttWindow *np = NULL;
512  struct MuttWindow *tmp = NULL;
513  TAILQ_FOREACH_SAFE(np, head, entries, tmp)
514  {
515  TAILQ_REMOVE(head, np, entries);
517  mutt_window_free(&np);
518  }
519 }
520 
530 {
531  if (!win)
532  return false;
533 
534  for (; win; win = win->parent)
535  {
536  if (!win->state.visible)
537  return false;
538  }
539 
540  return true;
541 }
542 
551 {
552  if (!win)
553  return NULL;
554  if (win->type == type)
555  return win;
556 
557  struct MuttWindow *np = NULL;
558  struct MuttWindow *match = NULL;
559  TAILQ_FOREACH(np, &win->children, entries)
560  {
561  match = window_find_child(np, type);
562  if (match)
563  return match;
564  }
565 
566  return NULL;
567 }
568 
576 {
577  for (; win; win = win->parent)
578  {
579  if (win->type == type)
580  return win;
581  }
582 
583  return NULL;
584 }
585 
590 static void window_recalc(struct MuttWindow *win)
591 {
592  if (!win || !win->state.visible)
593  return;
594 
595  if (win->recalc && (win->actions & WA_RECALC))
596  win->recalc(win);
597  win->actions &= ~WA_RECALC;
598 
599  struct MuttWindow *np = NULL;
600  TAILQ_FOREACH(np, &win->children, entries)
601  {
602  window_recalc(np);
603  }
604 }
605 
610 static void window_repaint(struct MuttWindow *win)
611 {
612  if (!win || !win->state.visible)
613  return;
614 
615  if (win->repaint && (win->actions & WA_REPAINT))
616  win->repaint(win);
617  win->actions &= ~WA_REPAINT;
618 
619  struct MuttWindow *np = NULL;
620  TAILQ_FOREACH(np, &win->children, entries)
621  {
622  window_repaint(np);
623  }
624 }
625 
632 void window_redraw(struct MuttWindow *win)
633 {
634  if (!win)
635  win = RootWindow;
636 
637  window_reflow(win);
638  window_notify_all(win);
639 
640  window_recalc(win);
641  window_repaint(win);
642  mutt_refresh();
643 }
644 
650 bool window_is_focused(struct MuttWindow *win)
651 {
652  if (!win)
653  return false;
654 
656 
657  return (win_focus == win);
658 }
659 
665 {
666  struct MuttWindow *win = RootWindow;
667 
668  while (win && win->focus)
669  win = win->focus;
670 
671  return win;
672 }
673 
681 {
682  if (!win)
683  return NULL;
684 
685  struct MuttWindow *old_focus = window_get_focus();
686 
687  struct MuttWindow *parent = win->parent;
688  struct MuttWindow *child = win;
689 
690  // Set the chain of focus, all the way to the root
691  for (; parent; child = parent, parent = parent->parent)
692  parent->focus = child;
693 
694  // Find the most focussed Window
695  while (win && win->focus)
696  win = win->focus;
697 
698  if (win == old_focus)
699  return NULL;
700 
701  mutt_debug(LL_NOTIFY, "NT_WINDOW_FOCUS: %s, %p\n", mutt_window_win_name(win), win);
702  struct EventWindow ev_w = { win, WN_NO_FLAGS };
704 #ifdef USE_DEBUG_WINDOW
705  debug_win_dump();
706 #endif
707  return old_focus;
708 }
709 
717 {
718  if (!mutt_window_is_visible(win))
719  return;
720 
721  for (int i = 0; i < win->state.rows; i++)
722  mutt_window_clearline(win, i);
723 }
724 
731 const char *mutt_window_win_name(const struct MuttWindow *win)
732 {
733  if (!win)
734  return "UNKNOWN";
735 
736  const char *name = mutt_map_get_name(win->type, WindowNames);
737  if (name)
738  return name;
739  return "UNKNOWN";
740 }
741 
746 static void window_invalidate(struct MuttWindow *win)
747 {
748  if (!win)
749  return;
750 
751  win->actions |= WA_REPAINT;
752 
753  struct MuttWindow *np = NULL;
754  TAILQ_FOREACH(np, &win->children, entries)
755  {
756  window_invalidate(np);
757  }
758 }
759 
764 {
766  clearok(stdscr, true);
767  keypad(stdscr, true);
768 }
769 
780 bool window_status_on_top(struct MuttWindow *panel, struct ConfigSubset *sub)
781 {
782  const bool c_status_on_top = cs_subset_bool(sub, "status_on_top");
783 
784  struct MuttWindow *win_first = TAILQ_FIRST(&panel->children);
785 
786  if ((c_status_on_top && (win_first->type == WT_STATUS_BAR)) ||
787  (!c_status_on_top && (win_first->type != WT_STATUS_BAR)))
788  {
789  return false;
790  }
791 
792  TAILQ_REMOVE(&panel->children, win_first, entries);
793  TAILQ_INSERT_TAIL(&panel->children, win_first, entries);
794 
795  mutt_window_reflow(panel);
796  mutt_debug(LL_DEBUG5, "config done, request WA_REFLOW\n");
797  return true;
798 }
New Window has been added.
Definition: mutt_window.h:205
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:550
#define WN_NARROWER
Window became narrower.
Definition: mutt_window.h:190
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
Define wrapper functions around Curses/Slang.
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
struct MuttWindow * mutt_window_remove_child(struct MuttWindow *parent, struct MuttWindow *child)
Remove a child from a Window.
Definition: mutt_window.c:488
enum MuttWindowOrientation orient
Which direction the Window will expand.
Definition: mutt_window.h:130
History Dialog, dlg_select_history()
Definition: mutt_window.h:85
#define TAILQ_FIRST(head)
Definition: queue.h:723
void(* wdata_free)(struct MuttWindow *win, void **ptr)
Definition: mutt_window.h:160
#define WA_REPAINT
Redraw the contents of the Window.
Definition: mutt_window.h:111
struct MuttWindow * win
Window that changed.
Definition: mutt_window.h:217
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
Window management.
Log of notifications.
Definition: logging.h:45
GUI miscellaneous curses (window drawing) routines.
An Event that happened to a Window.
Definition: mutt_window.h:215
Crypt-GPGME Dialog, dlg_select_gpgme_key()
Definition: mutt_window.h:83
Window for messages/errors and command entry.
Definition: mutt_window.h:99
Attach Dialog, dlg_select_attachment()
Definition: mutt_window.h:78
bool window_status_on_top(struct MuttWindow *panel, struct ConfigSubset *sub)
Organise windows according to config variable.
Definition: mutt_window.c:780
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:73
static bool is_visible(struct Email *e)
Is the message visible?
Definition: mutt_thread.c:132
void mutt_window_clrtoeol(struct MuttWindow *win)
Clear to the end of the line.
Definition: mutt_window.c:259
Pgp Dialog, dlg_select_pgp_key()
Definition: mutt_window.h:88
static bool window_was_visible(struct MuttWindow *win)
Was the Window visible?
Definition: mutt_window.c:86
#define WN_NO_FLAGS
No flags are set.
Definition: mutt_window.h:186
Query Dialog, dlg_select_query()
Definition: mutt_window.h:90
WindowType
Type of Window.
Definition: mutt_window.h:69
MuttWindowOrientation
Which way does the Window expand?
Definition: mutt_window.h:36
Invisible shaping container Window.
Definition: mutt_window.h:73
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:735
Parent of All Windows.
Definition: mutt_window.h:72
struct MuttWindow * window_set_focus(struct MuttWindow *win)
Set the Window focus.
Definition: mutt_window.c:680
#define WN_WIDER
Window became wider.
Definition: mutt_window.h:189
Window is about to be deleted.
Definition: mutt_window.h:206
void window_redraw(struct MuttWindow *win)
Reflow, recalc and repaint a tree of Windows.
Definition: mutt_window.c:632
WHERE bool OptNoCurses
(pseudo) when sending in batch mode
Definition: options.h:47
#define WN_HIDDEN
Window became hidden.
Definition: mutt_window.h:193
Window focus has changed.
Definition: mutt_window.h:209
short col_offset
Absolute on-screen column.
Definition: mutt_window.h:62
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:324
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:53
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:102
Convenience wrapper for the config headers.
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:310
A panel containing the Index Window.
Definition: mutt_window.h:97
void mutt_window_free(struct MuttWindow **ptr)
Free a Window and its children.
Definition: mutt_window.c:200
struct MuttWindow * focus
Focussed Window.
Definition: mutt_window.h:140
WindowActionFlags actions
Actions to be performed, e.g. WA_RECALC.
Definition: mutt_window.h:132
const char * mutt_map_get_name(int val, const struct Mapping *map)
Lookup a string for a constant.
Definition: mapping.c:42
static struct MuttWindow * win_focus
Definition: window.c:36
void mutt_window_clear(struct MuttWindow *win)
Clear a Window.
Definition: mutt_window.c:716
struct Notify * notify
Notifications: NotifyWindow, EventWindow.
Definition: mutt_window.h:138
Log at debug level 2.
Definition: logging.h:41
void mutt_window_clearline(struct MuttWindow *win, int row)
Clear a row of a Window.
Definition: mutt_window.c:247
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition: mutt_window.c:434
struct MuttWindow * window_get_focus(void)
Get the currently focussed Window.
Definition: mutt_window.c:664
void mutt_winlist_free(struct MuttWindowList *head)
Free a tree of Windows.
Definition: mutt_window.c:506
#define TAILQ_INIT(head)
Definition: queue.h:765
static void window_repaint(struct MuttWindow *win)
Repaint a tree of Windows.
Definition: mutt_window.c:610
Window with a custom drawing function.
Definition: mutt_window.h:95
Browser Dialog, mutt_buffer_select_file()
Definition: mutt_window.h:80
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:841
Window state has changed, e.g. WN_VISIBLE.
Definition: mutt_window.h:207
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
Autocrypt Dialog, dlg_select_autocrypt_account()
Definition: mutt_window.h:79
static void window_invalidate(struct MuttWindow *win)
Mark a window as in need of repaint.
Definition: mutt_window.c:746
void mutt_refresh(void)
Force a refresh of the screen.
Definition: curs_lib.c:115
Side panel containing Accounts or groups of data.
Definition: mutt_window.h:101
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:60
A set of inherited config items.
Definition: subset.h:46
void window_reflow(struct MuttWindow *win)
Reflow Windows.
Definition: reflow.c:222
void mutt_window_get_coords(struct MuttWindow *win, int *col, int *row)
Get the cursor position in the Window.
Definition: mutt_window.c:290
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
#define WN_TALLER
Window became taller.
Definition: mutt_window.h:187
bool visible
Window is visible.
Definition: mutt_window.h:59
bool mutt_window_is_visible(struct MuttWindow *win)
Is the Window visible?
Definition: mutt_window.c:529
short row_offset
Absolute on-screen row.
Definition: mutt_window.h:63
static void window_recalc(struct MuttWindow *win)
Recalculate a tree of Windows.
Definition: mutt_window.c:590
short rows
Number of rows, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:61
int mutt_window_printf(struct MuttWindow *win, const char *fmt,...)
Write a formatted string to a Window.
Definition: mutt_window.c:453
uint8_t WindowNotifyFlags
Changes to a MuttWindow.
Definition: mutt_window.h:185
static void window_notify(struct MuttWindow *win)
Notify observers of changes to a Window.
Definition: mutt_window.c:104
Help Bar containing list of useful key bindings.
Definition: mutt_window.h:96
struct MuttWindow * window_find_parent(struct MuttWindow *win, enum WindowType type)
Find a (grand-)parent of a Window by type.
Definition: mutt_window.c:575
#define WN_SHORTER
Window became shorter.
Definition: mutt_window.h:188
struct WindowState old
Previous state of the Window.
Definition: mutt_window.h:128
int mutt_window_wrap_cols(int width, short wrap)
Calculate the wrap column for a given screen width.
Definition: mutt_window.c:386
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:809
Pager Dialog, mutt_do_pager()
Definition: mutt_window.h:84
enum MuttWindowSize size
Type of Window, e.g. MUTT_WIN_SIZE_FIXED.
Definition: mutt_window.h:131
#define mutt_debug(LEVEL,...)
Definition: logging.h:85
Container for All Dialogs (nested Windows)
Definition: mutt_window.h:74
void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
Add a child to Window.
Definition: mutt_window.c:468
Window management.
The current, or old, state of a Window.
Definition: mutt_window.h:57
void window_notify_all(struct MuttWindow *win)
Notify observers of changes to a Window and its children.
Definition: mutt_window.c:143
A panel containing the Pager Window.
Definition: mutt_window.h:100
Smime Dialog, dlg_select_smime_key()
Definition: mutt_window.h:92
Convenience wrapper for the debug headers.
struct MuttWindow * RootWindow
Parent of all Windows.
Definition: rootwin.c:105
bool window_is_focused(struct MuttWindow *win)
Does the given Window have the focus?
Definition: mutt_window.c:650
Compose Dialog, mutt_compose_menu()
Definition: mutt_window.h:82
void window_set_visible(struct MuttWindow *win, bool visible)
Set a Window visible or hidden.
Definition: mutt_window.c:163
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:361
struct MuttWindow * parent
Parent Window.
Definition: mutt_window.h:135
#define WN_VISIBLE
Window became visible.
Definition: mutt_window.h:192
Root Window.
Postpone Dialog, dlg_select_postponed_email()
Definition: mutt_window.h:89
int(* repaint)(struct MuttWindow *win)
Definition: mutt_window.h:182
#define FREE(x)
Definition: memory.h:40
Mapping between user-readable string and a constant.
Definition: mapping.h:31
MuttWindowSize
Control the allocation of Window space.
Definition: mutt_window.h:45
struct MuttWindowList children
Children Windows.
Definition: mutt_window.h:136
short req_rows
Number of rows required.
Definition: mutt_window.h:125
int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
Write a partial string to a Window.
Definition: mutt_window.c:415
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:343
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:93
int(* recalc)(struct MuttWindow *win)
Definition: mutt_window.h:171
void debug_win_dump(void)
Definition: window.c:91
Handling of global boolean variables.
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:180
Index Dialog, index_pager_init()
Definition: mutt_window.h:86
Log at debug level 5.
Definition: logging.h:44
Convenience wrapper for the library headers.
const char * mutt_window_win_name(const struct MuttWindow *win)
Get the name of a Window.
Definition: mutt_window.c:731
Certificate Dialog, dlg_verify_certificate()
Definition: mutt_window.h:81
void * wdata
Private data.
Definition: mutt_window.h:145
void window_invalidate_all(void)
Mark all windows as in need of repaint.
Definition: mutt_window.c:763
enum WindowType type
Window type, e.g. WT_SIDEBAR.
Definition: mutt_window.h:144
An Window containing a Menu.
Definition: mutt_window.h:98
int mutt_window_addch(struct MuttWindow *win, int ch)
Write one character to a Window.
Definition: mutt_window.c:402
#define WN_MOVED
Window moved.
Definition: mutt_window.h:191
Alias Dialog, dlg_select_alias()
Definition: mutt_window.h:77
Remailer Dialog, dlg_select_mixmaster_chain()
Definition: mutt_window.h:91
short req_cols
Number of columns required.
Definition: mutt_window.h:124
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
#define WA_RECALC
Recalculate the contents of the Window.
Definition: mutt_window.h:110