mutt_window.c File Reference

Window management. More...

#include "config.h"
#include <stdarg.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "debug/lib.h"
#include "mutt_window.h"
#include "mutt_curses.h"
#include "mutt_globals.h"
#include "mutt_menu.h"
#include "options.h"
#include "reflow.h"

Include dependency graph for mutt_window.c:

Go to the source code of this file.

Functions
static void	window_notify (struct MuttWindow *win)
	Notify observers of changes to a Window. More...
void	window_notify_all (struct MuttWindow *win)
	Notify observers of changes to a Window and its children. More...
void	window_set_visible (struct MuttWindow *win, bool visible)
	Set a Window (and its children) visible or hidden. More...
struct MuttWindow *	mutt_window_new (enum WindowType type, enum MuttWindowOrientation orient, enum MuttWindowSize size, int cols, int rows)
	Create a new Window. More...
void	mutt_window_free (struct MuttWindow **ptr)
	Free a Window and its children. More...
void	mutt_window_clearline (struct MuttWindow *win, int row)
	Clear a row of a Window. More...
void	mutt_window_clrtobot (void)
	Clear to the bottom of the Window. More...
void	mutt_window_clrtoeol (struct MuttWindow *win)
	Clear to the end of the line. More...
static int	mutt_dlg_rootwin_observer (struct NotifyCallback *nc)
	Listen for config changes affecting the Root Window - Implements observer_t. More...
void	mutt_window_free_all (void)
	Free all the default Windows. More...
void	mutt_window_get_coords (struct MuttWindow *win, int *col, int *row)
	Get the cursor position in the Window. More...
void	mutt_window_init (void)
	Create the default Windows. More...
int	mutt_window_move (struct MuttWindow *win, int col, int row)
	Move the cursor in a Window. More...
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. More...
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. More...
void	mutt_window_copy_size (const struct MuttWindow *win_src, struct MuttWindow *win_dst)
	Copy the size of one Window to another. More...
void	mutt_window_reflow (struct MuttWindow *win)
	Resize a Window and its children. More...
void	mutt_window_reflow_message_rows (int mw_rows)
	Resize the Message Window. More...
int	mutt_window_wrap_cols (int width, short wrap)
	Calculate the wrap column for a given screen width. More...
int	mutt_window_addch (int ch)
	Write one character to a Window. More...
int	mutt_window_addnstr (const char *str, int num)
	Write a partial string to a Window. More...
int	mutt_window_addstr (const char *str)
	Write a string to a Window. More...
void	mutt_window_move_abs (int col, int row)
	Move the cursor to an absolute screen position. More...
int	mutt_window_printf (const char *fmt,...)
	Write a formatted string to a Window. More...
void	mutt_window_add_child (struct MuttWindow *parent, struct MuttWindow *child)
	Add a child to Window. More...
struct MuttWindow *	mutt_window_remove_child (struct MuttWindow *parent, struct MuttWindow *child)
	Remove a child from a Window. More...
void	mutt_winlist_free (struct MuttWindowList *head)
	Free a tree of Windows. More...
void	mutt_window_set_root (int cols, int rows)
	Set the dimensions of the Root Window. More...
bool	mutt_window_is_visible (struct MuttWindow *win)
	Is the Window visible? More...
struct MuttWindow *	mutt_window_dialog (struct MuttWindow *win)
	Find the parent Dialog of a Window. More...
struct MuttWindow *	mutt_window_find (struct MuttWindow *root, enum WindowType type)
	Find a Window of a given type. More...
void	dialog_push (struct MuttWindow *dlg)
	Display a Window to the user. More...
void	dialog_pop (void)
	Hide a Window from the user. More...
void	window_recalc (struct MuttWindow *win)
	Recalculate a tree of Windows. More...
void	window_repaint (struct MuttWindow *win)
	Repaint a tree of Windows. More...
void	window_redraw (struct MuttWindow *win)
	Reflow, recalc and repaint a tree of Windows. More...

Variables
struct MuttWindow *	RootWindow = NULL
	Parent of all Windows. More...
struct MuttWindow *	MuttDialogWindow = NULL
	Parent of all Dialogs. More...
struct MuttWindow *	MuttHelpWindow = NULL
	Help Window. More...
struct MuttWindow *	MuttMessageWindow = NULL
	Message Window. More...

Detailed Description

Window management.

Authors

• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file mutt_window.c.

Function Documentation

window_notify()

static void window_notify ( struct MuttWindow *  win )

static

Notify observers of changes to a Window.

Parameters

win

Window

Definition at line 52 of file mutt_window.c.

{
  if (!win->notify)
    return;

  const struct WindowState *old = &win->old;
  const struct WindowState *new = &win->state;
  WindowNotifyFlags flags = WN_NO_FLAGS;

  if (new->visible != old->visible)
    flags |= new->visible ? WN_VISIBLE : WN_HIDDEN;

  if ((new->row_offset != old->row_offset) || (new->col_offset != old->col_offset))
    flags |= WN_MOVED;

  if (new->rows > old->rows)
    flags |= WN_TALLER;
  else if (new->rows < old->rows)
    flags |= WN_SHORTER;

  if (new->cols > old->cols)
    flags |= WN_WIDER;
  else if (new->cols < old->cols)
    flags |= WN_NARROWER;

  if (flags == WN_NO_FLAGS)
    return;

  struct EventWindow ev_w = { win, flags };
  notify_send(win->notify, NT_WINDOW, NT_WINDOW_STATE, &ev_w);
  win->old = win->state;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_notify_all()

void window_notify_all

(

struct MuttWindow *

win

)

Notify observers of changes to a Window and its children.

Parameters

win

Window

Definition at line 89 of file mutt_window.c.

{
  if (!win)
    win = RootWindow;

  window_notify(win);

  struct MuttWindow *np = NULL;
  TAILQ_FOREACH(np, &win->children, entries)
  {
    window_notify_all(np);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_visible()

void window_set_visible	(	struct MuttWindow *	win,
		bool	visible
	)

Set a Window (and its children) visible or hidden.

Parameters

win	Window
visible	If true, make Window visible, otherwise hidden

Definition at line 108 of file mutt_window.c.

{
  if (!win)
    win = RootWindow;

  win->state.visible = visible;

  struct MuttWindow *np = NULL;
  TAILQ_FOREACH(np, &win->children, entries)
  {
    window_set_visible(np, visible);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_new()

struct MuttWindow* mutt_window_new	(	enum WindowType	type,
		enum MuttWindowOrientation	orient,
		enum MuttWindowSize	size,
		int	cols,
		int	rows
	)

Create a new Window.

Parameters

type	Window type, e.g. WT_ROOT
orient	Window orientation, e.g. MUTT_WIN_ORIENT_VERTICAL
size	Window size, e.g. MUTT_WIN_SIZE_MAXIMISE
cols	Initial number of columns to allocate, can be MUTT_WIN_SIZE_UNLIMITED
rows	Initial number of rows to allocate, can be MUTT_WIN_SIZE_UNLIMITED

Return values

ptr	New Window

Definition at line 131 of file mutt_window.c.

{
  struct MuttWindow *win = mutt_mem_calloc(1, sizeof(struct MuttWindow));

  win->type = type;
  win->orient = orient;
  win->size = size;
  win->req_rows = rows;
  win->req_cols = cols;
  win->state.visible = true;
  win->notify = notify_new();
  TAILQ_INIT(&win->children);
  return win;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_free()

void mutt_window_free

(

struct MuttWindow **

ptr

)

Free a Window and its children.

Parameters

ptr	Window to free

Definition at line 151 of file mutt_window.c.

{
  if (!ptr || !*ptr)
    return;

  struct MuttWindow *win = *ptr;

  struct EventWindow ev_w = { win, WN_NO_FLAGS };
  notify_send(win->notify, NT_WINDOW, NT_WINDOW_DELETE, &ev_w);

  mutt_winlist_free(&win->children);

  if (win->wdata && win->wdata_free)
    win->wdata_free(win, &win->wdata); // Custom function to free private data

  notify_free(&win->notify);

  FREE(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_clearline()

void mutt_window_clearline	(	struct MuttWindow *	win,
		int	row
	)

Clear a row of a Window.

Parameters

win	Window
row	Row to clear

Definition at line 194 of file mutt_window.c.

{
  mutt_window_move(win, 0, row);
  mutt_window_clrtoeol(win);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_clrtobot()

void mutt_window_clrtobot

(

void

)

Clear to the bottom of the Window.

Note

Assumes the cursor has already been positioned within the Window.

Definition at line 205 of file mutt_window.c.

{
  clrtobot();
}

Here is the caller graph for this function:

mutt_window_clrtoeol()

void mutt_window_clrtoeol

(

struct MuttWindow *

win

)

Clear to the end of the line.

Parameters

win

Window

Note

Assumes the cursor has already been positioned within the window.

Definition at line 216 of file mutt_window.c.

{
  if (!win || !stdscr)
    return;

  if (win->state.col_offset + win->state.cols == COLS)
    clrtoeol();
  else
  {
    int row = 0;
    int col = 0;
    getyx(stdscr, row, col);
    int curcol = col;
    while (curcol < (win->state.col_offset + win->state.cols))
    {
      addch(' ');
      curcol++;
    }
    move(row, col);
  }
}

Here is the caller graph for this function:

mutt_dlg_rootwin_observer()

static int mutt_dlg_rootwin_observer ( struct NotifyCallback *  nc )

static

Listen for config changes affecting the Root Window - Implements observer_t.

Definition at line 241 of file mutt_window.c.

{
  if (!nc->event_data || !nc->global_data)
    return -1;
  if (nc->event_type != NT_CONFIG)
    return 0;

  struct EventConfig *ec = nc->event_data;
  struct MuttWindow *root_win = nc->global_data;

  if (mutt_str_equal(ec->name, "help"))
  {
    MuttHelpWindow->state.visible = C_Help;
    goto reflow;
  }

  if (mutt_str_equal(ec->name, "status_on_top"))
  {
    struct MuttWindow *first = TAILQ_FIRST(&root_win->children);
    if (!first)
      return -1;

    if ((C_StatusOnTop && (first->type == WT_HELP_BAR)) ||
        (!C_StatusOnTop && (first->type != WT_HELP_BAR)))
    {
      // Swap the HelpLine and the Dialogs Container
      struct MuttWindow *next = TAILQ_NEXT(first, entries);
      if (!next)
        return -1;
      TAILQ_REMOVE(&root_win->children, next, entries);
      TAILQ_INSERT_HEAD(&root_win->children, next, entries);
    }
  }

reflow:
  mutt_window_reflow(root_win);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_free_all()

void mutt_window_free_all

(

void

)

Free all the default Windows.

Definition at line 283 of file mutt_window.c.

{
  if (NeoMutt)
    notify_observer_remove(NeoMutt->notify, mutt_dlg_rootwin_observer, RootWindow);
  MuttDialogWindow = NULL;
  MuttHelpWindow = NULL;
  MuttMessageWindow = NULL;
  mutt_window_free(&RootWindow);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_get_coords()

void mutt_window_get_coords	(	struct MuttWindow *	win,
		int *	col,
		int *	row
	)

Get the cursor position in the Window.

Parameters

[in]	win	Window
[out]	col	Column in Window
[out]	row	Row in Window

Assumes the current position is inside the window. Otherwise it will happily return negative or values outside the window boundaries

Definition at line 302 of file mutt_window.c.

{
  int x = 0;
  int y = 0;

  getyx(stdscr, y, x);
  if (col)
    *col = x - win->state.col_offset;
  if (row)
    *row = y - win->state.row_offset;
}

Here is the caller graph for this function:

mutt_window_init()

void mutt_window_init

(

void

)

Create the default Windows.

Create the Help, Index, Status, Message and Sidebar Windows.

Definition at line 319 of file mutt_window.c.

{
  if (RootWindow)
    return;

  RootWindow =
      mutt_window_new(WT_ROOT, MUTT_WIN_ORIENT_VERTICAL, MUTT_WIN_SIZE_FIXED, 0, 0);
  notify_set_parent(RootWindow->notify, NeoMutt->notify);

  MuttHelpWindow = mutt_window_new(WT_HELP_BAR, MUTT_WIN_ORIENT_VERTICAL,
                                   MUTT_WIN_SIZE_FIXED, MUTT_WIN_SIZE_UNLIMITED, 1);
  MuttHelpWindow->state.visible = C_Help;

  MuttDialogWindow = mutt_window_new(WT_ALL_DIALOGS, MUTT_WIN_ORIENT_VERTICAL,
                                     MUTT_WIN_SIZE_MAXIMISE, MUTT_WIN_SIZE_UNLIMITED,
                                     MUTT_WIN_SIZE_UNLIMITED);

  MuttMessageWindow = mutt_window_new(WT_MESSAGE, MUTT_WIN_ORIENT_VERTICAL,
                                      MUTT_WIN_SIZE_FIXED, MUTT_WIN_SIZE_UNLIMITED, 1);

  if (C_StatusOnTop)
  {
    mutt_window_add_child(RootWindow, MuttDialogWindow);
    mutt_window_add_child(RootWindow, MuttHelpWindow);
  }
  else
  {
    mutt_window_add_child(RootWindow, MuttHelpWindow);
    mutt_window_add_child(RootWindow, MuttDialogWindow);
  }

  mutt_window_add_child(RootWindow, MuttMessageWindow);
  notify_observer_add(NeoMutt->notify, mutt_dlg_rootwin_observer, RootWindow);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_move()

int mutt_window_move	(	struct MuttWindow *	win,
		int	col,
		int	row
	)

Move the cursor in a Window.

Parameters

win	Window
col	Column to move to
row	Row to move to

Return values

OK	Success
ERR	Error

Definition at line 362 of file mutt_window.c.

{
  return move(win->state.row_offset + row, win->state.col_offset + col);
}

Here is the caller graph for this function:

mutt_window_mvaddstr()

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.

Parameters

win	Window to write to
col	Column to move to
row	Row to move to
str	String to write

Return values

OK	Success
ERR	Error

Definition at line 376 of file mutt_window.c.

{
#ifdef USE_SLANG_CURSES
  return mvaddstr(win->state.row_offset + row, win->state.col_offset + col, (char *) str);
#else
  return mvaddstr(win->state.row_offset + row, win->state.col_offset + col, str);
#endif
}

Here is the caller graph for this function:

mutt_window_mvprintw()

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.

Parameters

win	Window to write to
col	Column to move to
row	Row to move to
fmt	printf format string
...	printf arguments

Return values

num	Success, characters written
ERR	Error, move failed

Definition at line 395 of file mutt_window.c.

{
  int rc = mutt_window_move(win, col, row);
  if (rc == ERR)
    return rc;

  va_list ap;
  va_start(ap, fmt);
  rc = vw_printw(stdscr, fmt, ap);
  va_end(ap);

  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_copy_size()

void mutt_window_copy_size	(	const struct MuttWindow *	win_src,
		struct MuttWindow *	win_dst
	)

Copy the size of one Window to another.

Parameters

win_src	Window to copy
win_dst	Window to resize

Definition at line 414 of file mutt_window.c.

{
  if (!win_src || !win_dst)
    return;

  win_dst->state.rows = win_src->state.rows;
  win_dst->state.cols = win_src->state.cols;
  win_dst->state.row_offset = win_src->state.row_offset;
  win_dst->state.col_offset = win_src->state.col_offset;
}

mutt_window_reflow()

void mutt_window_reflow

(

struct MuttWindow *

win

)

Resize a Window and its children.

Parameters

win	Window to resize

Definition at line 429 of file mutt_window.c.

{
  if (OptNoCurses)
    return;

  if (!win)
    win = RootWindow;

  mutt_debug(LL_DEBUG2, "entering\n");
  window_reflow(win);
  window_notify_all(win);

  mutt_menu_set_current_redraw_full();
  /* the pager menu needs this flag set to recalc line_info */
  mutt_menu_set_current_redraw(REDRAW_FLOW);
#ifdef USE_DEBUG_WINDOW
  debug_win_dump();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_reflow_message_rows()

void mutt_window_reflow_message_rows

(

int

mw_rows

)

Resize the Message Window.

Parameters

mw_rows

Number of rows required

Resize the other Windows to allow a multi-line message to be displayed.

Definition at line 455 of file mutt_window.c.

{
  MuttMessageWindow->req_rows = mw_rows;
  mutt_window_reflow(MuttMessageWindow->parent);

  /* We don't also set REDRAW_FLOW because this function only
   * changes rows and is a temporary adjustment. */
  mutt_menu_set_current_redraw_full();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_wrap_cols()

int mutt_window_wrap_cols	(	int	width,
		short	wrap
	)

Calculate the wrap column for a given screen width.

Parameters

width	Screen width
wrap	Wrap config

Return values

num	Column that text should be wrapped at

The wrap variable can be negative, meaning there should be a right margin.

Definition at line 473 of file mutt_window.c.

{
  if (wrap < 0)
    return (width > -wrap) ? (width + wrap) : width;
  if (wrap)
    return (wrap < width) ? wrap : width;
  return width;
}

Here is the caller graph for this function:

mutt_window_addch()

int mutt_window_addch

(

int

ch

)

Write one character to a Window.

Parameters

ch	Character to write

Return values

0	Success
-1	Error

Definition at line 488 of file mutt_window.c.

{
  return addch(ch);
}

Here is the caller graph for this function:

mutt_window_addnstr()

int mutt_window_addnstr	(	const char *	str,
		int	num
	)

Write a partial string to a Window.

Parameters

str	String
num	Maximum number of characters to write

Return values

0	Success
-1	Error

Definition at line 500 of file mutt_window.c.

{
  if (!str)
    return -1;

#ifdef USE_SLANG_CURSES
  return addnstr((char *) str, num);
#else
  return addnstr(str, num);
#endif
}

Here is the caller graph for this function:

mutt_window_addstr()

int mutt_window_addstr

(

const char *

str

)

Write a string to a Window.

Parameters

str

String

Return values

0	Success
-1	Error

Definition at line 518 of file mutt_window.c.

{
  if (!str)
    return -1;

#ifdef USE_SLANG_CURSES
  return addstr((char *) str);
#else
  return addstr(str);
#endif
}

Here is the caller graph for this function:

mutt_window_move_abs()

void mutt_window_move_abs	(	int	col,
		int	row
	)

Move the cursor to an absolute screen position.

Parameters

col	Screen column (0-based)
row	Screen row (0-based)

Definition at line 535 of file mutt_window.c.

{
  move(row, col);
}

Here is the caller graph for this function:

mutt_window_printf()

int mutt_window_printf	(	const char *	fmt,
			...
	)

Write a formatted string to a Window.

Parameters

fmt	Format string
...	Arguments

Return values

num	Number of characters written

Definition at line 546 of file mutt_window.c.

{
  va_list ap;
  va_start(ap, fmt);
  int rc = vw_printw(stdscr, fmt, ap);
  va_end(ap);

  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_add_child()

void mutt_window_add_child	(	struct MuttWindow *	parent,
		struct MuttWindow *	child
	)

Add a child to Window.

Parameters

parent	Window to add to
child	Window to add

Definition at line 561 of file mutt_window.c.

{
  if (!parent || !child)
    return;

  TAILQ_INSERT_TAIL(&parent->children, child, entries);
  child->parent = parent;

  notify_set_parent(child->notify, parent->notify);

  struct EventWindow ev_w = { child, WN_NO_FLAGS };
  notify_send(child->notify, NT_WINDOW, NT_WINDOW_NEW, &ev_w);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_remove_child()

struct MuttWindow* mutt_window_remove_child	(	struct MuttWindow *	parent,
		struct MuttWindow *	child
	)

Remove a child from a Window.

Parameters

parent	Window to remove from
child	Window to remove

Definition at line 580 of file mutt_window.c.

{
  if (!parent || !child)
    return NULL;

  struct EventWindow ev_w = { child, WN_NO_FLAGS };
  notify_send(child->notify, NT_WINDOW, NT_WINDOW_DELETE, &ev_w);

  TAILQ_REMOVE(&parent->children, child, entries);
  child->parent = NULL;

  notify_set_parent(child->notify, NULL);

  return child;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_winlist_free()

void mutt_winlist_free

(

struct MuttWindowList *

head

)

Free a tree of Windows.

Parameters

head	WindowList to free

Definition at line 600 of file mutt_window.c.

{
  if (!head)
    return;

  struct MuttWindow *np = NULL;
  struct MuttWindow *tmp = NULL;
  TAILQ_FOREACH_SAFE(np, head, entries, tmp)
  {
    TAILQ_REMOVE(head, np, entries);
    mutt_winlist_free(&np->children);
    mutt_window_free(&np);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_set_root()

void mutt_window_set_root	(	int	cols,
		int	rows
	)

Set the dimensions of the Root Window.

Parameters

rows
cols

Definition at line 620 of file mutt_window.c.

{
  if (!RootWindow)
    return;

  bool changed = false;

  if (RootWindow->state.rows != rows)
  {
    RootWindow->state.rows = rows;
    changed = true;
  }

  if (RootWindow->state.cols != cols)
  {
    RootWindow->state.cols = cols;
    changed = true;
  }

  if (changed)
  {
    mutt_window_reflow(RootWindow);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_window_is_visible()

bool mutt_window_is_visible

(

struct MuttWindow *

win

)

Is the Window visible?

Parameters

win

Window

Return values

true	If the Window is visible

For a Window to be visible, it must be visible and it's parent and grandparent, etc.

Definition at line 653 of file mutt_window.c.

{
  if (!win)
    return false;

  for (; win; win = win->parent)
  {
    if (!win->state.visible)
      return false;
  }

  return true;
}

Here is the caller graph for this function:

mutt_window_dialog()

struct MuttWindow* mutt_window_dialog

(

struct MuttWindow *

win

)

Find the parent Dialog of a Window.

Parameters

win

Window

Return values

ptr

Dialog

Dialog Windows will be owned by a MuttWindow of type WT_ALL_DIALOGS.

Definition at line 674 of file mutt_window.c.

{
  for (; win && win->parent; win = win->parent)
  {
    if (win->parent->type == WT_ALL_DIALOGS)
      return win;
  }

  return NULL;
}

Here is the caller graph for this function:

mutt_window_find()

struct MuttWindow* mutt_window_find	(	struct MuttWindow *	root,
		enum WindowType	type
	)

Find a Window of a given type.

Parameters

root	Window to start searching
type	Window type to find, e.g. WT_INDEX_BAR

Return values

ptr	Matching Window
NULL	No match

Definition at line 692 of file mutt_window.c.

{
  if (!root)
    return NULL;
  if (root->type == type)
    return root;

  struct MuttWindow *np = NULL;
  struct MuttWindow *match = NULL;
  TAILQ_FOREACH(np, &root->children, entries)
  {
    match = mutt_window_find(np, type);
    if (match)
      return match;
  }

  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dialog_push()

void dialog_push

(

struct MuttWindow *

dlg

)

Display a Window to the user.

Parameters

dlg	Window to display

The Dialog Windows are kept in a stack. The topmost is visible to the user, whilst the others are hidden.

When a Window is pushed, the old Window is marked as not visible.

Definition at line 720 of file mutt_window.c.

{
  if (!dlg || !MuttDialogWindow)
    return;

  struct MuttWindow *last = TAILQ_LAST(&MuttDialogWindow->children, MuttWindowList);
  if (last)
    last->state.visible = false;

  TAILQ_INSERT_TAIL(&MuttDialogWindow->children, dlg, entries);
  notify_set_parent(dlg->notify, MuttDialogWindow->notify);

  // Notify the world, allowing plugins to integrate
  struct EventWindow ev_w = { dlg, WN_VISIBLE };
  notify_send(dlg->notify, NT_WINDOW, NT_WINDOW_DIALOG, &ev_w);

  dlg->state.visible = true;
  dlg->parent = MuttDialogWindow;
  mutt_window_reflow(MuttDialogWindow);
#ifdef USE_DEBUG_WINDOW
  debug_win_dump();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

dialog_pop()

void dialog_pop

(

void

)

Hide a Window from the user.

The topmost (visible) Window is removed from the stack and the next Window is marked as visible.

Definition at line 750 of file mutt_window.c.

{
  if (!MuttDialogWindow)
    return;

  struct MuttWindow *last = TAILQ_LAST(&MuttDialogWindow->children, MuttWindowList);
  if (!last)
    return;

  // Notify the world, allowing plugins to clean up
  struct EventWindow ev_w = { last, WN_HIDDEN };
  notify_send(last->notify, NT_WINDOW, NT_WINDOW_DIALOG, &ev_w);

  last->state.visible = false;
  last->parent = NULL;
  TAILQ_REMOVE(&MuttDialogWindow->children, last, entries);

  last = TAILQ_LAST(&MuttDialogWindow->children, MuttWindowList);
  if (last)
  {
    last->state.visible = true;
    mutt_window_reflow(MuttDialogWindow);
  }
  mutt_menu_set_current_redraw(REDRAW_FULL);
#ifdef USE_DEBUG_WINDOW
  debug_win_dump();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_recalc()

void window_recalc

(

struct MuttWindow *

win

)

Recalculate a tree of Windows.

Parameters

win	Window to start at

Definition at line 783 of file mutt_window.c.

{
  if (!win)
    return;

  if (win->recalc)
    win->recalc(win, false);

  struct MuttWindow *np = NULL;
  TAILQ_FOREACH(np, &win->children, entries)
  {
    if (np->recalc)
      np->recalc(np, false);
  }
}

Here is the caller graph for this function:

window_repaint()

void window_repaint

(

struct MuttWindow *

win

)

Repaint a tree of Windows.

Parameters

win	Window to start at

Definition at line 803 of file mutt_window.c.

{
  if (!win)
    return;

  if (win->repaint)
    win->repaint(win, false);

  struct MuttWindow *np = NULL;
  TAILQ_FOREACH(np, &win->children, entries)
  {
    if (np->repaint)
      np->repaint(np, false);
  }
}

Here is the caller graph for this function:

window_redraw()

void window_redraw

(

struct MuttWindow *

win

)

Reflow, recalc and repaint a tree of Windows.

Parameters

win	Window to start at

Definition at line 823 of file mutt_window.c.

{
  if (!win)
    return;

  window_reflow(win);
  window_notify_all(win);

  window_recalc(win);
  window_repaint(win);
}

Here is the call graph for this function:

Variable Documentation

RootWindow

struct MuttWindow* RootWindow = NULL

Parent of all Windows.

Definition at line 43 of file mutt_window.c.

MuttDialogWindow

struct MuttWindow* MuttDialogWindow = NULL

Parent of all Dialogs.

Definition at line 44 of file mutt_window.c.

MuttHelpWindow

struct MuttWindow* MuttHelpWindow = NULL

Help Window.

Definition at line 45 of file mutt_window.c.

MuttMessageWindow

struct MuttWindow* MuttMessageWindow = NULL

Message Window.

Definition at line 46 of file mutt_window.c.