NeoMutt  2020-11-20
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 "core/lib.h"
35 #include "debug/lib.h"
36 #include "mutt_window.h"
37 #include "helpbar/lib.h"
38 #include "mutt_curses.h"
39 #include "mutt_globals.h"
40 #include "mutt_menu.h"
41 #include "opcodes.h"
42 #include "options.h"
43 #include "reflow.h"
44 
45 struct MuttWindow *RootWindow = NULL;
46 struct MuttWindow *AllDialogsWindow = NULL;
47 struct MuttWindow *MessageWindow = NULL;
48 
50 static const struct Mapping EditorHelp[] = {
51  // clang-format off
52  { N_("Complete"), OP_EDITOR_COMPLETE },
53  { N_("Hist Up"), OP_EDITOR_HISTORY_UP },
54  { N_("Hist Down"), OP_EDITOR_HISTORY_DOWN },
55  { N_("Hist Search"), OP_EDITOR_HISTORY_SEARCH },
56  { N_("Begin Line"), OP_EDITOR_BOL },
57  { N_("End Line"), OP_EDITOR_EOL },
58  { N_("Kill Line"), OP_EDITOR_KILL_LINE },
59  { N_("Kill Word"), OP_EDITOR_KILL_WORD },
60  { NULL, 0 },
61  // clang-format off
62 };
63 
73 static bool window_was_visible(struct MuttWindow *win)
74 {
75  if (!win)
76  return false;
77 
78  for (; win; win = win->parent)
79  {
80  if (!win->old.visible)
81  return false;
82  }
83 
84  return true;
85 }
86 
91 static void window_notify(struct MuttWindow *win)
92 {
93  if (!win->notify)
94  return;
95 
96  const struct WindowState *old = &win->old;
97  const struct WindowState *state = &win->state;
99 
100  const bool was_visible = window_was_visible(win);
101  const bool is_visible = mutt_window_is_visible(win);
102  if (was_visible != is_visible)
103  flags |= is_visible ? WN_VISIBLE : WN_HIDDEN;
104 
105  if ((state->row_offset != old->row_offset) || (state->col_offset != old->col_offset))
106  flags |= WN_MOVED;
107 
108  if (state->rows > old->rows)
109  flags |= WN_TALLER;
110  else if (state->rows < old->rows)
111  flags |= WN_SHORTER;
112 
113  if (state->cols > old->cols)
114  flags |= WN_WIDER;
115  else if (state->cols < old->cols)
116  flags |= WN_NARROWER;
117 
118  if (flags == WN_NO_FLAGS)
119  return;
120 
121  struct EventWindow ev_w = { win, flags };
123 }
124 
130 {
131  if (!win)
132  win = RootWindow;
133 
134  window_notify(win);
135 
136  struct MuttWindow *np = NULL;
137  TAILQ_FOREACH(np, &win->children, entries)
138  {
139  window_notify_all(np);
140  }
141  win->old = win->state;
142 }
143 
149 void window_set_visible(struct MuttWindow *win, bool visible)
150 {
151  if (!win)
152  win = RootWindow;
153 
154  win->state.visible = visible;
155 }
156 
167  enum MuttWindowSize size, int cols, int rows)
168 {
169  struct MuttWindow *win = mutt_mem_calloc(1, sizeof(struct MuttWindow));
170 
171  win->type = type;
172  win->orient = orient;
173  win->size = size;
174  win->req_rows = rows;
175  win->req_cols = cols;
176  win->state.visible = true;
177  win->notify = notify_new();
178  TAILQ_INIT(&win->children);
179  return win;
180 }
181 
186 void mutt_window_free(struct MuttWindow **ptr)
187 {
188  if (!ptr || !*ptr)
189  return;
190 
191  struct MuttWindow *win = *ptr;
192 
193  if (win->parent && (win->parent->focus == win))
194  win->parent->focus = NULL;
195 
196  struct EventWindow ev_w = { win, WN_NO_FLAGS };
198 
200 
201  if (win->wdata && win->wdata_free)
202  win->wdata_free(win, &win->wdata); // Custom function to free private data
203 
204  notify_free(&win->notify);
205 
206  FREE(ptr);
207 }
208 
209 #ifdef USE_SLANG_CURSES
210 
217 static int vw_printw(SLcurses_Window_Type *win, const char *fmt, va_list ap)
218 {
219  char buf[1024];
220 
221  (void) SLvsnprintf(buf, sizeof(buf), (char *) fmt, ap);
222  SLcurses_waddnstr(win, buf, -1);
223  return 0;
224 }
225 #endif
226 
232 void mutt_window_clearline(struct MuttWindow *win, int row)
233 {
234  mutt_window_move(win, 0, row);
236 }
237 
245 {
246  if (!win || !stdscr)
247  return;
248 
249  if (win->state.col_offset + win->state.cols == COLS)
250  clrtoeol();
251  else
252  {
253  int row = 0;
254  int col = 0;
255  getyx(stdscr, row, col);
256  int curcol = col;
257  while (curcol < (win->state.col_offset + win->state.cols))
258  {
259  addch(' ');
260  curcol++;
261  }
262  move(row, col);
263  }
264 }
265 
270 {
271  if (!nc->event_data || !nc->global_data)
272  return -1;
273  if (nc->event_type != NT_CONFIG)
274  return 0;
275 
276  struct EventConfig *ec = nc->event_data;
277  struct MuttWindow *root_win = nc->global_data;
278 
279  if (mutt_str_equal(ec->name, "status_on_top"))
280  {
281  struct MuttWindow *first = TAILQ_FIRST(&root_win->children);
282  if (!first)
283  return -1;
284 
285  if ((C_StatusOnTop && (first->type == WT_HELP_BAR)) ||
286  (!C_StatusOnTop && (first->type != WT_HELP_BAR)))
287  {
288  // Swap the HelpLine and the Dialogs Container
289  struct MuttWindow *next = TAILQ_NEXT(first, entries);
290  if (!next)
291  return -1;
292  TAILQ_REMOVE(&root_win->children, next, entries);
293  TAILQ_INSERT_HEAD(&root_win->children, next, entries);
294  }
295  }
296 
297  mutt_window_reflow(root_win);
298  return 0;
299 }
300 
305 {
306  if (NeoMutt)
308  AllDialogsWindow = NULL;
309  MessageWindow = NULL;
310  mutt_window_free(&RootWindow);
311 }
312 
322 void mutt_window_get_coords(struct MuttWindow *win, int *col, int *row)
323 {
324  int x = 0;
325  int y = 0;
326 
327  getyx(stdscr, y, x);
328  if (col)
329  *col = x - win->state.col_offset;
330  if (row)
331  *row = y - win->state.row_offset;
332 }
333 
340 {
341  if (RootWindow)
342  return;
343 
344  RootWindow =
346  notify_set_parent(RootWindow->notify, NeoMutt->notify);
347 
348  struct MuttWindow *win_helpbar = helpbar_create();
349 
353 
356  MessageWindow->help_data = EditorHelp;
357  MessageWindow->help_menu = MENU_EDITOR;
358 
359  if (C_StatusOnTop)
360  {
361  mutt_window_add_child(RootWindow, AllDialogsWindow);
362  mutt_window_add_child(RootWindow, win_helpbar);
363  }
364  else
365  {
366  mutt_window_add_child(RootWindow, win_helpbar);
367  mutt_window_add_child(RootWindow, AllDialogsWindow);
368  }
369 
370  mutt_window_add_child(RootWindow, MessageWindow);
372 }
373 
382 int mutt_window_move(struct MuttWindow *win, int col, int row)
383 {
384  return move(win->state.row_offset + row, win->state.col_offset + col);
385 }
386 
396 int mutt_window_mvaddstr(struct MuttWindow *win, int col, int row, const char *str)
397 {
398 #ifdef USE_SLANG_CURSES
399  return mvaddstr(win->state.row_offset + row, win->state.col_offset + col, (char *) str);
400 #else
401  return mvaddstr(win->state.row_offset + row, win->state.col_offset + col, str);
402 #endif
403 }
404 
415 int mutt_window_mvprintw(struct MuttWindow *win, int col, int row, const char *fmt, ...)
416 {
417  int rc = mutt_window_move(win, col, row);
418  if (rc == ERR)
419  return rc;
420 
421  va_list ap;
422  va_start(ap, fmt);
423  rc = vw_printw(stdscr, fmt, ap);
424  va_end(ap);
425 
426  return rc;
427 }
428 
434 {
435  if (OptNoCurses)
436  return;
437 
438  if (!win)
439  win = RootWindow;
440 
441  mutt_debug(LL_DEBUG2, "entering\n");
442  window_reflow(win);
443  window_notify_all(win);
444 
446  /* the pager menu needs this flag set to recalc line_info */
448 #ifdef USE_DEBUG_WINDOW
449  debug_win_dump();
450 #endif
451 }
452 
460 {
461  MessageWindow->req_rows = mw_rows;
462  mutt_window_reflow(MessageWindow->parent);
463 
464  /* We don't also set REDRAW_FLOW because this function only
465  * changes rows and is a temporary adjustment. */
467 }
468 
477 int mutt_window_wrap_cols(int width, short wrap)
478 {
479  if (wrap < 0)
480  return (width > -wrap) ? (width + wrap) : width;
481  if (wrap)
482  return (wrap < width) ? wrap : width;
483  return width;
484 }
485 
492 int mutt_window_addch(int ch)
493 {
494  return addch(ch);
495 }
496 
504 int mutt_window_addnstr(const char *str, int num)
505 {
506  if (!str)
507  return -1;
508 
509 #ifdef USE_SLANG_CURSES
510  return addnstr((char *) str, num);
511 #else
512  return addnstr(str, num);
513 #endif
514 }
515 
522 int mutt_window_addstr(const char *str)
523 {
524  if (!str)
525  return -1;
526 
527 #ifdef USE_SLANG_CURSES
528  return addstr((char *) str);
529 #else
530  return addstr(str);
531 #endif
532 }
533 
539 void mutt_window_move_abs(int col, int row)
540 {
541  move(row, col);
542 }
543 
550 int mutt_window_printf(const char *fmt, ...)
551 {
552  va_list ap;
553  va_start(ap, fmt);
554  int rc = vw_printw(stdscr, fmt, ap);
555  va_end(ap);
556 
557  return rc;
558 }
559 
565 void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
566 {
567  if (!parent || !child)
568  return;
569 
570  TAILQ_INSERT_TAIL(&parent->children, child, entries);
571  child->parent = parent;
572 
573  notify_set_parent(child->notify, parent->notify);
574 
575  struct EventWindow ev_w = { child, WN_NO_FLAGS };
576  notify_send(child->notify, NT_WINDOW, NT_WINDOW_NEW, &ev_w);
577 }
578 
585 {
586  if (!parent || !child)
587  return NULL;
588 
589  struct EventWindow ev_w = { child, WN_NO_FLAGS };
590  notify_send(child->notify, NT_WINDOW, NT_WINDOW_DELETE, &ev_w);
591 
592  TAILQ_REMOVE(&parent->children, child, entries);
593  child->parent = NULL;
594 
595  notify_set_parent(child->notify, NULL);
596 
597  return child;
598 }
599 
604 void mutt_winlist_free(struct MuttWindowList *head)
605 {
606  if (!head)
607  return;
608 
609  struct MuttWindow *np = NULL;
610  struct MuttWindow *tmp = NULL;
611  TAILQ_FOREACH_SAFE(np, head, entries, tmp)
612  {
613  TAILQ_REMOVE(head, np, entries);
615  mutt_window_free(&np);
616  }
617 }
618 
624 void mutt_window_set_root(int cols, int rows)
625 {
626  if (!RootWindow)
627  return;
628 
629  bool changed = false;
630 
631  if (RootWindow->state.rows != rows)
632  {
633  RootWindow->state.rows = rows;
634  changed = true;
635  }
636 
637  if (RootWindow->state.cols != cols)
638  {
639  RootWindow->state.cols = cols;
640  changed = true;
641  }
642 
643  if (changed)
644  {
645  mutt_window_reflow(RootWindow);
646  }
647 }
648 
658 {
659  if (!win)
660  return false;
661 
662  for (; win; win = win->parent)
663  {
664  if (!win->state.visible)
665  return false;
666  }
667 
668  return true;
669 }
670 
679 {
680  if (!root)
681  return NULL;
682  if (root->type == type)
683  return root;
684 
685  struct MuttWindow *np = NULL;
686  struct MuttWindow *match = NULL;
687  TAILQ_FOREACH(np, &root->children, entries)
688  {
689  match = mutt_window_find(np, type);
690  if (match)
691  return match;
692  }
693 
694  return NULL;
695 }
696 
701 static void window_recalc(struct MuttWindow *win)
702 {
703  if (!win)
704  return;
705 
706  if (win->recalc)
707  {
708  win->recalc(win);
709  win->actions &= ~WA_RECALC;
710  }
711 
712  struct MuttWindow *np = NULL;
713  TAILQ_FOREACH(np, &win->children, entries)
714  {
715  window_recalc(np);
716  }
717 }
718 
724 static void window_repaint(struct MuttWindow *win, bool force)
725 {
726  if (!win)
727  return;
728 
729  if (win->repaint && (force || (win->actions & WA_REPAINT)))
730  {
731  win->repaint(win);
732  win->actions &= ~WA_REPAINT;
733  }
734 
735  struct MuttWindow *np = NULL;
736  TAILQ_FOREACH(np, &win->children, entries)
737  {
738  window_repaint(np, force);
739  }
740 }
741 
747 void window_redraw(struct MuttWindow *win, bool force)
748 {
749  if (!win)
750  return;
751 
752  window_reflow(win);
753  window_notify_all(win);
754 
755  window_recalc(win);
756  window_repaint(win, force);
757 }
758 
763 void window_set_focus(struct MuttWindow *win)
764 {
765  if (!win)
766  return;
767 
768  struct MuttWindow *parent = win->parent;
769  struct MuttWindow *child = win;
770 
771  // Set the chain of focus, all the way to the root
772  for (; parent; child = parent, parent = parent->parent)
773  parent->focus = child;
774 
775  // Find the most focussed Window
776  while (win && win->focus)
777  win = win->focus;
778 
779  struct EventWindow ev_w = { win, WN_NO_FLAGS };
781 #ifdef USE_DEBUG_WINDOW
782  debug_win_dump();
783 #endif
784 }
785 
791 {
792  struct MuttWindow *win = RootWindow;
793 
794  while (win && win->focus)
795  win = win->focus;
796 
797  return win;
798 }
799 
806 void mutt_window_clear(struct MuttWindow *win)
807 {
808  if (!mutt_window_is_visible(win))
809  return;
810 
811  for (int i = 0; i < win->state.rows; i++)
812  mutt_window_clearline(win, i);
813 }
814 
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:871
static int mutt_dlg_rootwin_observer(struct NotifyCallback *nc)
Listen for config changes affecting the Root Window - Implements observer_t.
Definition: mutt_window.c:269
#define WN_NARROWER
Window became narrower.
Definition: mutt_window.h:169
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.
struct MuttWindow * mutt_window_remove_child(struct MuttWindow *parent, struct MuttWindow *child)
Remove a child from a Window.
Definition: mutt_window.c:584
enum MuttWindowOrientation orient
Which direction the Window will expand.
Definition: mutt_window.h:123
#define TAILQ_FIRST(head)
Definition: queue.h:716
void(* wdata_free)(struct MuttWindow *win, void **ptr)
Free the private data attached to the MuttWindow.
Definition: mutt_window.h:145
#define WA_REPAINT
Redraw the contents of the Window.
Definition: mutt_window.h:108
Data passed to a notification function.
Definition: observer.h:39
struct MuttWindow * win
Window that changed.
Definition: mutt_window.h:193
void mutt_window_init(void)
Create the default Windows.
Definition: mutt_window.c:339
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
Window management.
void window_set_focus(struct MuttWindow *win)
Set the Window focus.
Definition: mutt_window.c:763
An Event that happened to a Window.
Definition: mutt_window.h:191
Window for messages/errors and command entry.
Definition: mutt_window.h:96
int help_menu
Menu for key bindings, e.g. MENU_PAGER.
Definition: mutt_window.h:134
Window uses all available vertical space.
Definition: mutt_window.h:35
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:62
#define REDRAW_FLOW
Used by pager to reflow text.
Definition: mutt_menu.h:47
static bool is_visible(struct Email *e)
Is the message visible?
Definition: mutt_thread.c:73
void mutt_window_free_all(void)
Free all the default Windows.
Definition: mutt_window.c:304
struct MuttWindow * mutt_window_find(struct MuttWindow *root, enum WindowType type)
Find a Window of a given type.
Definition: mutt_window.c:678
void mutt_window_clrtoeol(struct MuttWindow *win)
Clear to the end of the line.
Definition: mutt_window.c:244
static bool window_was_visible(struct MuttWindow *win)
Was the Window visible?
Definition: mutt_window.c:73
#define WN_NO_FLAGS
No flags are set.
Definition: mutt_window.h:165
WindowType
Type of Window.
Definition: mutt_window.h:66
MuttWindowOrientation
Which way does the Window expand?
Definition: mutt_window.h:33
A config-change event.
Definition: subset.h:70
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:728
Parent of All Windows.
Definition: mutt_window.h:69
#define WN_WIDER
Window became wider.
Definition: mutt_window.h:168
static const struct Mapping EditorHelp[]
Help Bar for the Command Line Editor.
Definition: mutt_window.c:50
Window is about to be deleted.
Definition: mutt_window.h:182
WHERE bool OptNoCurses
(pseudo) when sending in batch mode
Definition: options.h:48
#define WN_HIDDEN
Window became hidden.
Definition: mutt_window.h:172
Window focus has changed.
Definition: mutt_window.h:185
A division of the screen.
Definition: mutt_window.h:115
void mutt_window_move_abs(int col, int row)
Move the cursor to an absolute screen position.
Definition: mutt_window.c:539
short col_offset
Absolute on-screen column.
Definition: mutt_window.h:59
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:396
All user-callable functions.
Container for Accounts, Notifications.
Definition: neomutt.h:36
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:43
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:382
void mutt_window_free(struct MuttWindow **ptr)
Free a Window and its children.
Definition: mutt_window.c:186
enum NotifyType event_type
Send: Event type, e.g. NT_ACCOUNT.
Definition: observer.h:42
struct MuttWindow * focus
Focussed Window.
Definition: mutt_window.h:133
WindowActionFlags actions
Actions to be performed, e.g. WA_RECALC.
Definition: mutt_window.h:125
int mutt_window_addnstr(const char *str, int num)
Write a partial string to a Window.
Definition: mutt_window.c:504
void mutt_window_clear(struct MuttWindow *win)
Clear a Window.
Definition: mutt_window.c:806
struct Notify * notify
Notifications system.
Definition: mutt_window.h:131
static void window_repaint(struct MuttWindow *win, bool force)
Repaint a tree of Windows.
Definition: mutt_window.c:724
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:232
struct MuttWindow * window_get_focus(void)
Get the currently focussed Window.
Definition: mutt_window.c:790
Convenience wrapper for the core headers.
New Window has been added.
Definition: mutt_window.h:181
void mutt_winlist_free(struct MuttWindowList *head)
Free a tree of Windows.
Definition: mutt_window.c:604
struct MuttWindow * helpbar_create(void)
Create the Help Bar Window.
Definition: helpbar.c:263
#define TAILQ_INIT(head)
Definition: queue.h:758
Help Bar Convenience wrapper for the Help Bar headers.
bool notify_observer_add(struct Notify *notify, enum NotifyType type, observer_t callback, void *global_data)
Add an observer to an object.
Definition: notify.c:169
void * global_data
Data from notify_observer_add()
Definition: observer.h:45
Window has a fixed size.
Definition: mutt_window.h:44
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:834
void mutt_window_reflow_message_rows(int mw_rows)
Resize the Message Window.
Definition: mutt_window.c:459
Window state has changed, e.g. WN_VISIBLE.
Definition: mutt_window.h:183
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:57
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:49
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:322
void mutt_window_set_root(int cols, int rows)
Set the dimensions of the Root Window.
Definition: mutt_window.c:624
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:120
#define WN_TALLER
Window became taller.
Definition: mutt_window.h:166
struct MuttWindow * RootWindow
Parent of all Windows.
Definition: mutt_window.c:45
bool visible
Window is visible.
Definition: mutt_window.h:56
bool mutt_window_is_visible(struct MuttWindow *win)
Is the Window visible?
Definition: mutt_window.c:657
short row_offset
Absolute on-screen row.
Definition: mutt_window.h:60
static void window_recalc(struct MuttWindow *win)
Recalculate a tree of Windows.
Definition: mutt_window.c:701
#define MUTT_WIN_SIZE_UNLIMITED
Use as much space as possible.
Definition: mutt_window.h:49
short rows
Number of rows, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:58
uint8_t WindowNotifyFlags
Changes to a MuttWindow.
Definition: mutt_window.h:164
static void window_notify(struct MuttWindow *win)
Notify observers of changes to a Window.
Definition: mutt_window.c:91
const struct Mapping * help_data
Data for the Help Bar.
Definition: mutt_window.h:135
Help Bar containing list of useful key bindings.
Definition: mutt_window.h:93
#define WN_SHORTER
Window became shorter.
Definition: mutt_window.h:167
GUI present the user with a selectable list.
struct WindowState old
Previous state of the Window.
Definition: mutt_window.h:121
int mutt_window_wrap_cols(int width, short wrap)
Calculate the wrap column for a given screen width.
Definition: mutt_window.c:477
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:802
enum MuttWindowSize size
Type of Window, e.g. MUTT_WIN_SIZE_FIXED.
Definition: mutt_window.h:124
struct Notify * notify
Notifications handler.
Definition: neomutt.h:38
Container for All Dialogs (nested Windows)
Definition: mutt_window.h:71
void * event_data
Data from notify_send()
Definition: observer.h:44
void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
Add a child to Window.
Definition: mutt_window.c:565
Window management.
The current, or old, state of a Window.
Definition: mutt_window.h:54
void window_notify_all(struct MuttWindow *win)
Notify observers of changes to a Window and its children.
Definition: mutt_window.c:129
Config has changed, NotifyConfig, EventConfig.
Definition: notify_type.h:37
#define TAILQ_INSERT_HEAD(head, elm, field)
Definition: queue.h:789
int mutt_window_printf(const char *fmt,...)
Write a formatted string to a Window.
Definition: mutt_window.c:550
int mutt_window_addch(int ch)
Write one character to a Window.
Definition: mutt_window.c:492
Convenience wrapper for the debug headers.
void window_set_visible(struct MuttWindow *win, bool visible)
Set a Window visible or hidden.
Definition: mutt_window.c:149
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:433
WHERE bool C_StatusOnTop
Config: Display the status bar at the top.
Definition: mutt_globals.h:164
struct MuttWindow * parent
Parent Window.
Definition: mutt_window.h:128
#define WN_VISIBLE
Window became visible.
Definition: mutt_window.h:171
int(* repaint)(struct MuttWindow *win)
Repaint the Window.
Definition: mutt_window.h:161
#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:42
struct MuttWindowList children
Children Windows.
Definition: mutt_window.h:129
short req_rows
Number of rows required.
Definition: mutt_window.h:118
Text entry area.
Definition: keymap.h:77
bool notify_observer_remove(struct Notify *notify, observer_t callback, void *global_data)
Remove an observer from an object.
Definition: notify.c:207
void window_redraw(struct MuttWindow *win, bool force)
Reflow, recalc and repaint a tree of Windows.
Definition: mutt_window.c:747
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:415
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:82
int mutt_window_addstr(const char *str)
Write a string to a Window.
Definition: mutt_window.c:522
#define TAILQ_NEXT(elm, field)
Definition: queue.h:825
int(* recalc)(struct MuttWindow *win)
Recalculate the Window data.
Definition: mutt_window.h:153
void debug_win_dump(void)
Definition: window.c:88
Hundreds of global variables to back the user variables.
Handling of global boolean variables.
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
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:166
Convenience wrapper for the library headers.
Window wants as much space as possible.
Definition: mutt_window.h:45
void * wdata
Private data.
Definition: mutt_window.h:138
#define N_(a)
Definition: message.h:32
enum WindowType type
Window type, e.g. WT_SIDEBAR.
Definition: mutt_window.h:137
const char * name
Name of config item that changed.
Definition: subset.h:73
#define WN_MOVED
Window moved.
Definition: mutt_window.h:170
short req_cols
Number of columns required.
Definition: mutt_window.h:117
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:152
#define WA_RECALC
Recalculate the contents of the Window.
Definition: mutt_window.h:107