Observer API

Prototype for a notification callback function. More...

Functions
static int	alias_alias_observer (struct NotifyCallback *nc)
	Notification that an Alias has changed - Implements observer_t -.
static int	alias_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	query_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
int	alias_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	attach_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	attach_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	autocrypt_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	autocrypt_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	browser_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	browser_mailbox_observer (struct NotifyCallback *nc)
	Notification that a Mailbox has changed - Implements observer_t -.
static int	browser_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	quoted_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	attach_email_observer (struct NotifyCallback *nc)
	Notification that the Email has changed - Implements observer_t -.
int	cbar_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
int	cbar_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	cbar_email_observer (struct NotifyCallback *nc)
	Notification that the Email has changed - Implements observer_t -.
static int	cbar_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	compose_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	compose_email_observer (struct NotifyCallback *nc)
	Notification that an Email has changed - Implements observer_t -.
static int	compose_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	preview_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	preview_email_observer (struct NotifyCallback *nc)
	Notification that the Email has changed - Implements observer_t -.
static int	preview_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	cc_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	env_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	env_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	env_email_observer (struct NotifyCallback *nc)
	Notification that the Email has changed - Implements observer_t -.
static int	env_header_observer (struct NotifyCallback *nc)
	Notification that a User Header has changed - Implements observer_t -.
static int	env_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	alldialogs_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	msgwin_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	rootwin_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	rootwin_resize_observer (struct NotifyCallback *nc)
	Notification that the terminal has been resized - Implements observer_t -.
static int	rootwin_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	sbar_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	sbar_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	simple_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	simple_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	helpbar_binding_observer (struct NotifyCallback *nc)
	Notification that a Key Binding has changed - Implements observer_t -.
static int	helpbar_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	helpbar_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	helpbar_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
int	main_hist_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has change - Implements observer_t -.
static int	imap_timeout_observer (struct NotifyCallback *nc)
	Notification that a timeout has occurred - Implements observer_t -.
static int	index_mailbox_observer (struct NotifyCallback *nc)
	Notification that a Mailbox has changed - Implements observer_t -.
static int	ibar_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	ibar_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	ibar_index_observer (struct NotifyCallback *nc)
	Notification that the Index has changed - Implements observer_t -.
static int	ibar_menu_observer (struct NotifyCallback *nc)
	Notification that a Menu has changed - Implements observer_t -.
static int	ibar_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	index_altern_observer (struct NotifyCallback *nc)
	Notification that an 'alternates' command has occurred - Implements observer_t -.
static int	index_attach_observer (struct NotifyCallback *nc)
	Notification that an 'attachments' command has occurred - Implements observer_t -.
static int	index_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	index_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	index_global_observer (struct NotifyCallback *nc)
	Notification that a Global event occurred - Implements observer_t -.
static int	index_index_observer (struct NotifyCallback *nc)
	Notification that the Index has changed - Implements observer_t -.
static int	index_menu_observer (struct NotifyCallback *nc)
	Notification that the Menu has changed - Implements observer_t -.
static int	index_score_observer (struct NotifyCallback *nc)
	Notification that a 'score' command has occurred - Implements observer_t -.
static int	index_subjrx_observer (struct NotifyCallback *nc)
	Notification that a 'subjectrx' command has occurred - Implements observer_t -.
static int	index_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	ipanel_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	ipanel_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	index_shared_mview_observer (struct NotifyCallback *nc)
	Notification that the MailboxView has changed - Implements observer_t -.
static int	index_shared_account_observer (struct NotifyCallback *nc)
	Notification that an Account has changed - Implements observer_t -.
static int	index_shared_mailbox_observer (struct NotifyCallback *nc)
	Notification that a Mailbox has changed - Implements observer_t -.
static int	index_shared_email_observer (struct NotifyCallback *nc)
	Notification that an Email has changed - Implements observer_t -.
int	key_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	main_timeout_observer (struct NotifyCallback *nc)
	Notification that a timeout has occurred - Implements observer_t -.
static int	menu_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	menu_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	menu_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
int	main_log_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
int	mview_mailbox_observer (struct NotifyCallback *nc)
	Notification that a Mailbox has changed - Implements observer_t -.
static int	gpgme_key_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	gpgme_key_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	pgp_key_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	pgp_key_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	dopager_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	dopager_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	pager_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	pager_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	pager_index_observer (struct NotifyCallback *nc)
	Notification that the Index has changed - Implements observer_t -.
static int	pager_pager_observer (struct NotifyCallback *nc)
	Notification that the Pager has changed - Implements observer_t -.
static int	pager_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	pbar_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	pbar_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	pbar_index_observer (struct NotifyCallback *nc)
	Notification that the Index has changed - Implements observer_t -.
static int	pbar_pager_observer (struct NotifyCallback *nc)
	Notification that the Pager has changed - Implements observer_t -.
static int	pbar_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	ppanel_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	ppanel_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	pattern_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	pattern_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	postponed_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	postponed_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static int	sb_account_observer (struct NotifyCallback *nc)
	Notification that an Account has changed - Implements observer_t -.
static int	sb_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	sb_command_observer (struct NotifyCallback *nc)
	Notification that a Command has occurred - Implements observer_t -.
static int	sb_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	sb_index_observer (struct NotifyCallback *nc)
	Notification that the Index has changed - Implements observer_t -.
static int	sb_mailbox_observer (struct NotifyCallback *nc)
	Notification that a Mailbox has changed - Implements observer_t -.
static int	sb_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
int	sb_insertion_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.

Detailed Description

Prototype for a notification callback function.

Parameters

[in]

nc

Callback data

Return values

0	Success
-1	Error

Precondition

nc is not NULL

nc->current is not NULL

Function Documentation

alias_alias_observer()

static int alias_alias_observer ( struct NotifyCallback * nc )

static

Notification that an Alias has changed - Implements observer_t -.

Definition at line 155 of file dlg_alias.c.

{
  if (nc->event_type != NT_ALIAS)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventAlias *ev_a = nc->event_data;
  struct Menu *menu = nc->global_data;
  struct AliasMenuData *mdata = menu->mdata;
  struct Alias *alias = ev_a->alias;
 
  if (nc->event_subtype == NT_ALIAS_ADD)
  {
    alias_array_alias_add(&mdata->ava, alias);
 
    if (alias_array_count_visible(&mdata->ava) != ARRAY_SIZE(&mdata->ava))
    {
      mutt_pattern_alias_func(NULL, mdata, PAA_VISIBLE, menu);
    }
  }
  else if (nc->event_subtype == NT_ALIAS_DELETE)
  {
    alias_array_alias_delete(&mdata->ava, alias);
 
    int vcount = alias_array_count_visible(&mdata->ava);
    int index = menu_get_index(menu);
    if ((index > (vcount - 1)) && (index > 0))
      menu_set_index(menu, index - 1);
  }
 
  alias_array_sort(&mdata->ava, mdata->sub);
 
  menu->max = alias_array_count_visible(&mdata->ava);
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "alias done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_window_observer()

static int alias_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Help Bar

Definition at line 202 of file dlg_alias.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_menu = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_menu)
    return 0;
 
  struct Menu *menu = win_menu->wdata;
 
  notify_observer_remove(NeoMutt->notify, alias_alias_observer, menu);
  notify_observer_remove(NeoMutt->sub->notify, alias_config_observer, menu);
  notify_observer_remove(win_menu->notify, alias_window_observer, win_menu);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_window_observer()

static int query_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 277 of file dlg_query.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_menu = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_menu)
    return 0;
 
  struct Menu *menu = win_menu->wdata;
 
  notify_observer_remove(NeoMutt->sub->notify, alias_config_observer, menu);
  notify_observer_remove(win_menu->notify, query_window_observer, win_menu);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

alias_config_observer()

int alias_config_observer

(

struct NotifyCallback *

nc

)

Notification that a Config Variable has changed - Implements observer_t -.

The Address Book Window is affected by changes to $alias_sort.

Definition at line 43 of file gui.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "alias_sort") && !mutt_str_equal(ev_c->name, "alias_format") &&
      !mutt_str_equal(ev_c->name, "query_format"))
  {
    return 0;
  }
 
  struct Menu *menu = nc->global_data;
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_config_observer()

int attach_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

The Address Book Window is affected by changes to $sort_attach.

Definition at line 108 of file dlg_attach.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "attach_format") && !mutt_str_equal(ev_c->name, "message_format"))
    return 0;
 
  struct Menu *menu = nc->global_data;
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_window_observer()

static int attach_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Help Bar

Definition at line 173 of file dlg_attach.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_menu = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_menu)
    return 0;
 
  struct Menu *menu = win_menu->wdata;
 
  notify_observer_remove(NeoMutt->sub->notify, attach_config_observer, menu);
  notify_observer_remove(win_menu->notify, attach_window_observer, win_menu);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

autocrypt_config_observer()

static int autocrypt_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

The Address Book Window is affected by changes to $sort_autocrypt.

Definition at line 186 of file dlg_autocrypt.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "autocrypt_acct_format"))
    return 0;
 
  struct Menu *menu = nc->global_data;
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

autocrypt_window_observer()

static int autocrypt_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Help Bar

Definition at line 212 of file dlg_autocrypt.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_menu = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_menu)
    return 0;
 
  struct Menu *menu = win_menu->wdata;
 
  notify_observer_remove(NeoMutt->sub->notify, autocrypt_config_observer, menu);
  notify_observer_remove(win_menu->notify, autocrypt_window_observer, win_menu);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

browser_config_observer()

static int browser_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 710 of file dlg_browser.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  struct BrowserPrivateData *priv = nc->global_data;
  struct Menu *menu = priv->menu;
 
  if (mutt_str_equal(ev_c->name, "browser_sort_dirs_first"))
  {
    struct BrowserState *state = &priv->state;
    browser_sort(state);
    browser_highlight_default(state, menu);
  }
  else if (!mutt_str_equal(ev_c->name, "browser_abbreviate_mailboxes") &&
           !mutt_str_equal(ev_c->name, "browser_sort") &&
           !mutt_str_equal(ev_c->name, "date_format") &&
           !mutt_str_equal(ev_c->name, "folder") &&
           !mutt_str_equal(ev_c->name, "folder_format") &&
           !mutt_str_equal(ev_c->name, "group_index_format") &&
           !mutt_str_equal(ev_c->name, "mailbox_folder_format"))
  {
    return 0;
  }
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

browser_mailbox_observer()

static int browser_mailbox_observer ( struct NotifyCallback * nc )

static

Notification that a Mailbox has changed - Implements observer_t -.

Find the matching Mailbox and update its details.

Definition at line 750 of file dlg_browser.c.

{
  if (nc->event_type != NT_MAILBOX)
    return 0;
  if (nc->event_subtype == NT_MAILBOX_DELETE)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct BrowserPrivateData *priv = nc->global_data;
 
  struct BrowserState *state = &priv->state;
  if (state->is_mailbox_list)
  {
    struct EventMailbox *ev_m = nc->event_data;
    struct Mailbox *m = ev_m->mailbox;
    struct FolderFile *ff = NULL;
    ARRAY_FOREACH(ff, &state->entry)
    {
      if (ff->gen != m->gen)
        continue;
 
      ff->has_new_mail = m->has_new;
      ff->msg_count = m->msg_count;
      ff->msg_unread = m->msg_unread;
      ff->notify_user = m->notify_user;
      ff->poll_new_mail = m->poll_new_mail;
      mutt_str_replace(&ff->desc, m->name);
      break;
    }
  }
 
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "mailbox done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

browser_window_observer()

static int browser_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Help Bar

Definition at line 795 of file dlg_browser.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct BrowserPrivateData *priv = nc->global_data;
  struct MuttWindow *win_menu = priv->menu->win;
 
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_menu)
    return 0;
 
  notify_observer_remove(NeoMutt->sub->notify, browser_config_observer, priv);
  notify_observer_remove(win_menu->notify, browser_window_observer, priv);
  notify_observer_remove(NeoMutt->notify, browser_mailbox_observer, priv);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

quoted_color_observer()

static int quoted_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

Definition at line 42 of file quoted.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
  enum ColorId cid = ev_c->cid;
 
  if (!COLOR_QUOTED(cid))
    return 0;
 
  // Find the highest-numbered quotedN in use
  for (int i = MT_COLOR_QUOTED9; i >= MT_COLOR_QUOTED0; i--)
  {
    if (simple_color_is_set(i))
    {
      NumQuotedColors = i - MT_COLOR_QUOTED0 + 1;
      break;
    }
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_email_observer()

static int attach_email_observer ( struct NotifyCallback * nc )

static

Notification that the Email has changed - Implements observer_t -.

Definition at line 127 of file attach.c.

{
  if (nc->event_type != NT_EMAIL)
    return 0;
  if (!nc->global_data)
    return -1;
  if (nc->event_subtype != NT_EMAIL_CHANGE_ATTACH)
    return 0;
 
  struct MuttWindow *win_attach = nc->global_data;
 
  win_attach->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "compose done, request WA_RECALC\n");
 
  return 0;
}

Here is the caller graph for this function:

cbar_color_observer()

int cbar_color_observer

(

struct NotifyCallback *

nc

)

Notification that a Color has changed - Implements observer_t -.

Definition at line 125 of file cbar.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
 
  // MT_COLOR_MAX is sent on `uncolor *`
  if ((ev_c->cid != MT_COLOR_STATUS) && (ev_c->cid != MT_COLOR_NORMAL) &&
      (ev_c->cid != MT_COLOR_MAX))
  {
    return 0;
  }
 
  struct MuttWindow *win_cbar = nc->global_data;
  win_cbar->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT\n");
 
  return 0;
}

Here is the caller graph for this function:

cbar_config_observer()

int cbar_config_observer

(

struct NotifyCallback *

nc

)

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 151 of file cbar.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  if (!mutt_str_equal(ev_c->name, "compose_format"))
    return 0;
 
  struct MuttWindow *win_cbar = nc->global_data;
  win_cbar->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cbar_email_observer()

static int cbar_email_observer ( struct NotifyCallback * nc )

static

Notification that the Email has changed - Implements observer_t -.

Definition at line 172 of file cbar.c.

{
  if (nc->event_type != NT_EMAIL)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win_cbar = nc->global_data;
  win_cbar->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "compose done, request WA_RECALC\n");
 
  return 0;
}

Here is the caller graph for this function:

cbar_window_observer()

static int cbar_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 189 of file cbar.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win_cbar = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_cbar)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    win_cbar->actions |= WA_RECALC | WA_REPAINT;
    mutt_debug(LL_DEBUG5, "window state done, request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    struct MuttWindow *dlg = win_cbar->parent;
    struct ComposeSharedData *shared = dlg->wdata;
 
    mutt_color_observer_remove(cbar_color_observer, win_cbar);
    notify_observer_remove(NeoMutt->sub->notify, cbar_config_observer, win_cbar);
    notify_observer_remove(shared->email->notify, cbar_email_observer, win_cbar);
    notify_observer_remove(win_cbar->notify, cbar_window_observer, win_cbar);
 
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compose_config_observer()

static int compose_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 164 of file dlg_compose.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  struct MuttWindow *dlg = nc->global_data;
 
  if (mutt_str_equal(ev_c->name, "status_on_top"))
  {
    window_status_on_top(dlg, NeoMutt->sub);
    mutt_debug(LL_DEBUG5, "config done, request WA_REFLOW\n");
  }
  else if (mutt_str_equal(ev_c->name, "compose_show_preview") ||
           mutt_str_equal(ev_c->name, "compose_preview_min_rows"))
  {
    dlg->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "config done, request WA_RECALC\n");
  }
  else if (mutt_str_equal(ev_c->name, "compose_preview_above_attachments"))
  {
    struct ComposeSharedData *shared = dlg->wdata;
 
    mutt_window_swap(dlg, shared->win_preview_bar, shared->win_attach_bar);
    mutt_window_swap(dlg, shared->win_preview, shared->adata->menu->win);
 
    dlg->actions |= WA_REPAINT;
    mutt_debug(LL_DEBUG5, "config done, request WA_REPAINT\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compose_email_observer()

static int compose_email_observer ( struct NotifyCallback * nc )

static

Notification that an Email has changed - Implements observer_t -.

Definition at line 202 of file dlg_compose.c.

{
  if (nc->event_type != NT_ENVELOPE)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct ComposeSharedData *shared = nc->global_data;
 
  if (nc->event_subtype == NT_ENVELOPE_FCC)
    shared->fcc_set = true;
 
  mutt_message_hook(shared->mailbox, shared->email, MUTT_SEND2_HOOK);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compose_window_observer()

static int compose_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 221 of file dlg_compose.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *dlg = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != dlg)
    return 0;
 
  struct ComposeSharedData *shared = dlg->wdata;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    dlg->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "window state done, request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    notify_observer_remove(NeoMutt->sub->notify, compose_config_observer, dlg);
    notify_observer_remove(shared->email->notify, compose_email_observer, shared);
    notify_observer_remove(dlg->notify, compose_window_observer, dlg);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

preview_color_observer()

static int preview_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

Definition at line 233 of file preview.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
  struct MuttWindow *win = nc->global_data;
 
  enum ColorId cid = ev_c->cid;
 
  switch (cid)
  {
    case MT_COLOR_BOLD:
    case MT_COLOR_NORMAL:
    case MT_COLOR_STATUS:
    case MT_COLOR_MAX: // Sent on `uncolor *`
      mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT\n");
      win->actions |= WA_REPAINT;
      break;
 
    default:
      break;
  }
  return 0;
}

Here is the caller graph for this function:

preview_email_observer()

static int preview_email_observer ( struct NotifyCallback * nc )

static

Notification that the Email has changed - Implements observer_t -.

Definition at line 264 of file preview.c.

{
  if (nc->event_type != NT_EMAIL)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
 
  win->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "email done, request WA_RECALC\n");
  return 0;
}

Here is the caller graph for this function:

preview_window_observer()

static int preview_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 281 of file preview.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    win->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "window state done, request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    struct PreviewWindowData *wdata = win->wdata;
 
    mutt_color_observer_remove(preview_color_observer, win);
    notify_observer_remove(win->notify, preview_window_observer, win);
    notify_observer_remove(wdata->email->notify, preview_email_observer, win);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cc_config_observer()

static int cc_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 50 of file config_cache.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0; // LCOV_EXCL_LINE
  if (!nc->event_data)
    return -1; // LCOV_EXCL_LINE
 
  struct EventConfig *ev_c = nc->event_data;
  if (!ev_c->name || !ev_c->he)
    return 0; // LCOV_EXCL_LINE
 
  if (mutt_str_equal(ev_c->name, "assumed_charset"))
  {
    CachedAssumedCharset = (const struct Slist *) cs_subset_he_native_get(ev_c->sub,
                                                                          ev_c->he, NULL);
  }
  else if (mutt_str_equal(ev_c->name, "charset"))
  {
    CachedCharset = (const char *) cs_subset_he_native_get(ev_c->sub, ev_c->he, NULL);
  }
  else if (mutt_str_equal(ev_c->name, "maildir_field_delimiter"))
  {
    CachedMaildirFieldDelimiter = (const char *) cs_subset_he_native_get(ev_c->sub,
                                                                         ev_c->he, NULL);
  }
 
  mutt_debug(LL_DEBUG5, "config done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

env_color_observer()

static int env_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

Definition at line 755 of file window.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
  struct MuttWindow *win_env = nc->global_data;
 
  enum ColorId cid = ev_c->cid;
 
  switch (cid)
  {
    case MT_COLOR_BOLD:
    case MT_COLOR_COMPOSE_HEADER:
    case MT_COLOR_COMPOSE_SECURITY_BOTH:
    case MT_COLOR_COMPOSE_SECURITY_ENCRYPT:
    case MT_COLOR_COMPOSE_SECURITY_NONE:
    case MT_COLOR_COMPOSE_SECURITY_SIGN:
    case MT_COLOR_NORMAL:
    case MT_COLOR_STATUS:
    case MT_COLOR_MAX: // Sent on `uncolor *`
      mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT\n");
      win_env->actions |= WA_REPAINT;
      break;
 
    default:
      break;
  }
  return 0;
}

Here is the caller graph for this function:

env_config_observer()

static int env_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 791 of file window.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  if (!ev_c->name)
    return 0;
 
  struct MuttWindow *win_env = nc->global_data;
 
  switch (ev_c->name[0])
  {
    case 'a':
      if (mutt_str_equal(ev_c->name, "autocrypt"))
        break;
      return 0;
    case 'c':
      if (mutt_str_equal(ev_c->name, "compose_show_user_headers") ||
          mutt_str_equal(ev_c->name, "crypt_opportunistic_encrypt"))
      {
        break;
      }
      return 0;
    case 'p':
      if (mutt_str_equal(ev_c->name, "pgp_sign_as"))
        break;
      return 0;
    case 's':
      if (mutt_str_equal(ev_c->name, "smime_encrypt_with") ||
          mutt_str_equal(ev_c->name, "smime_sign_as"))
      {
        break;
      }
      return 0;
    case 'x':
      if (mutt_str_equal(ev_c->name, "x_comment_to"))
        break;
      return 0;
    default:
      return 0;
  }
 
  win_env->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

env_email_observer()

static int env_email_observer ( struct NotifyCallback * nc )

static

Notification that the Email has changed - Implements observer_t -.

Definition at line 844 of file window.c.

{
  if ((nc->event_type != NT_EMAIL) && (nc->event_type != NT_ENVELOPE))
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win_env = nc->global_data;
 
  // pgp/smime/autocrypt menu, or external change
  if (nc->event_type == NT_EMAIL)
  {
    struct EnvelopeWindowData *wdata = win_env->wdata;
    update_crypt_info(wdata);
  }
 
  win_env->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "email done, request WA_RECALC\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

env_header_observer()

static int env_header_observer ( struct NotifyCallback * nc )

static

Notification that a User Header has changed - Implements observer_t -.

Definition at line 868 of file window.c.

{
  if (nc->event_type != NT_HEADER)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  const struct EventHeader *ev_h = nc->event_data;
  struct MuttWindow *win_env = nc->global_data;
  struct EnvelopeWindowData *wdata = win_env->wdata;
 
  struct Envelope *env = wdata->email->env;
 
  if ((nc->event_subtype == NT_HEADER_ADD) || (nc->event_subtype == NT_HEADER_CHANGE))
  {
    header_set(&env->userhdrs, ev_h->header);
    mutt_debug(LL_DEBUG5, "header done, request reflow\n");
    win_env->actions |= WA_RECALC;
    return 0;
  }
 
  if (nc->event_subtype == NT_HEADER_DELETE)
  {
    struct ListNode *removed = header_find(&env->userhdrs, ev_h->header);
    if (removed)
    {
      header_free(&env->userhdrs, removed);
      mutt_debug(LL_DEBUG5, "header done, request reflow\n");
      win_env->actions |= WA_RECALC;
    }
    return 0;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

env_window_observer()

static int env_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 907 of file window.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win_env = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_env)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    win_env->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "window state done, request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    struct EnvelopeWindowData *wdata = win_env->wdata;
 
    mutt_color_observer_remove(env_color_observer, win_env);
    notify_observer_remove(wdata->email->notify, env_email_observer, win_env);
    notify_observer_remove(NeoMutt->sub->notify, env_config_observer, win_env);
    notify_observer_remove(NeoMutt->notify, env_header_observer, win_env);
    notify_observer_remove(win_env->notify, env_window_observer, win_env);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

alldialogs_window_observer()

static int alldialogs_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the All Dialogs window

Definition at line 183 of file dialog.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_alldlgs = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_alldlgs)
    return 0;
 
  notify_observer_remove(win_alldlgs->notify, alldialogs_window_observer, win_alldlgs);
 
  AllDialogsWindow = NULL;
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

msgwin_window_observer()

static int msgwin_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• State (this window): refresh the window
• Delete (this window): clean up the resources held by the Message Window

Definition at line 326 of file msgwin.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    if (ev_w->flags & WN_HIDDEN)
    {
      msgwin_clear_text(win);
    }
 
    if (ev_w->flags & (WN_NARROWER | WN_WIDER))
    {
      struct MsgWinWindowData *wdata = win->wdata;
      msgwin_set_rows(win, msgwin_calc_rows(wdata, win->state.cols,
                                            buf_string(wdata->text)));
      win->actions |= WA_RECALC;
    }
    else
    {
      win->actions |= WA_REPAINT;
    }
    mutt_debug(LL_DEBUG5, "window state done, request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    notify_observer_remove(win->notify, msgwin_window_observer, win);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rootwin_config_observer()

static int rootwin_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

The Root Window is affected by changes to $status_on_top.

Definition at line 113 of file rootwin.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  struct MuttWindow *win_root = nc->global_data;
 
  if (!mutt_str_equal(ev_c->name, "status_on_top"))
    return 0;
 
  struct MuttWindow *first = TAILQ_FIRST(&win_root->children);
  if (!first)
    return 0;
 
  const bool c_status_on_top = cs_subset_bool(NeoMutt->sub, "status_on_top");
  if ((c_status_on_top && (first->type == WT_HELP_BAR)) ||
      (!c_status_on_top && (first->type != WT_HELP_BAR)))
  {
    // Swap the HelpBar and the AllDialogsWindow
    struct MuttWindow *next = TAILQ_NEXT(first, entries);
    if (!next)
      return 0;
    TAILQ_REMOVE(&win_root->children, next, entries);
    TAILQ_INSERT_HEAD(&win_root->children, next, entries);
 
    mutt_window_reflow(win_root);
    mutt_debug(LL_DEBUG5, "config done, request WA_REFLOW\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rootwin_resize_observer()

static int rootwin_resize_observer ( struct NotifyCallback * nc )

static

Notification that the terminal has been resized - Implements observer_t -.

This function is triggered by SIGWINCH.

Definition at line 153 of file rootwin.c.

{
  if (nc->event_type != NT_RESIZE)
    return 0;
  if (!nc->global_data)
    return -1;
 
  window_invalidate_all();
  mutt_resize_screen();
 
  mutt_debug(LL_DEBUG5, "window resize done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rootwin_window_observer()

static int rootwin_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Root Window

Definition at line 174 of file rootwin.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_root = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_root)
    return 0;
 
  notify_observer_remove(win_root->notify, rootwin_window_observer, win_root);
  if (NeoMutt)
  {
    notify_observer_remove(NeoMutt->sub->notify, rootwin_config_observer, win_root);
    notify_observer_remove(NeoMutt->notify_resize, rootwin_resize_observer, win_root);
  }
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sbar_color_observer()

static int sbar_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

This function is triggered by changes to the colour settings, from the color or uncolor, mono or unmono commands.

Definition at line 116 of file sbar.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
 
  // MT_COLOR_MAX is sent on `uncolor *`
  if ((ev_c->cid != MT_COLOR_STATUS) && (ev_c->cid != MT_COLOR_NORMAL) &&
      (ev_c->cid != MT_COLOR_MAX))
  {
    return 0;
  }
 
  struct MuttWindow *win_sbar = nc->global_data;
 
  win_sbar->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT\n");
 
  return 0;
}

Here is the caller graph for this function:

sbar_window_observer()

static int sbar_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• State (this window): refresh the window
• Delete (this window): clean up the resources held by the Simple Bar

Definition at line 148 of file sbar.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win_sbar = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_sbar)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    win_sbar->actions |= WA_REPAINT;
    mutt_debug(LL_DEBUG5, "window state done, request WA_REPAINT\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    mutt_color_observer_remove(sbar_color_observer, win_sbar);
    notify_observer_remove(win_sbar->notify, sbar_window_observer, win_sbar);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

simple_config_observer()

static int simple_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

The Simple Dialog is affected by changes to $status_on_top.

Definition at line 80 of file simple.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  if (!mutt_str_equal(ev_c->name, "status_on_top"))
    return 0;
 
  struct MuttWindow *dlg = nc->global_data;
  window_status_on_top(dlg, NeoMutt->sub);
  mutt_debug(LL_DEBUG5, "config done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

simple_window_observer()

static int simple_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Simple Dialog

Definition at line 104 of file simple.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *dlg = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != dlg)
    return 0;
 
  notify_observer_remove(NeoMutt->sub->notify, simple_config_observer, dlg);
  notify_observer_remove(dlg->notify, simple_window_observer, dlg);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

helpbar_binding_observer()

static int helpbar_binding_observer ( struct NotifyCallback * nc )

static

Notification that a Key Binding has changed - Implements observer_t -.

This function is triggered by changes to the key bindings, from either of the bind or macro commands.

Definition at line 184 of file helpbar.c.

{
  if (nc->event_type != NT_BINDING)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype >= NT_MACRO_ADD)
    return 0;
 
  struct MuttWindow *win_helpbar = nc->global_data;
  struct HelpbarWindowData *wdata = helpbar_wdata_get(win_helpbar);
  if (!wdata)
    return 0;
 
  struct EventBinding *ev_b = nc->event_data;
  if (wdata->help_menu != ev_b->menu)
    return 0;
 
  win_helpbar->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "binding done, request WA_RECALC\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

helpbar_color_observer()

static int helpbar_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

This function is triggered by changes to the colour settings, from the color or uncolor, mono or unmono commands.

Definition at line 213 of file helpbar.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
 
  // MT_COLOR_MAX is sent on `uncolor *`
  if ((ev_c->cid != MT_COLOR_STATUS) && (ev_c->cid != MT_COLOR_NORMAL) &&
      (ev_c->cid != MT_COLOR_MAX))
  {
    return 0;
  }
 
  struct MuttWindow *win_helpbar = nc->global_data;
 
  win_helpbar->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT\n");
  return 0;
}

Here is the caller graph for this function:

helpbar_config_observer()

static int helpbar_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

This function is triggered by changes to the config by the set, unset, reset, toggle, etc commands.

Definition at line 242 of file helpbar.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  if (!mutt_str_equal(ev_c->name, "help"))
    return 0;
 
  struct MuttWindow *win_helpbar = nc->global_data;
  win_helpbar->state.visible = cs_subset_bool(NeoMutt->sub, "help");
 
  mutt_window_reflow(win_helpbar->parent);
  mutt_debug(LL_DEBUG5, "config done: '%s', request WA_REFLOW on parent\n", ev_c->name);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

helpbar_window_observer()

static int helpbar_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Focus (global): regenerate the list of key bindings
• State (this window): regenerate the list of key bindings
• Delete (this window): clean up the resources held by the Help Bar

Definition at line 270 of file helpbar.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win_helpbar = nc->global_data;
 
  if (nc->event_subtype == NT_WINDOW_FOCUS)
  {
    if (!mutt_window_is_visible(win_helpbar))
      return 0;
 
    win_helpbar->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "window focus: request WA_RECALC\n");
    return 0;
  }
 
  // The next two notifications must be specifically for us
  struct EventWindow *ew = nc->event_data;
  if (ew->win != win_helpbar)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    win_helpbar->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "window state: request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    mutt_color_observer_remove(helpbar_color_observer, win_helpbar);
    notify_observer_remove(NeoMutt->notify, helpbar_binding_observer, win_helpbar);
    notify_observer_remove(NeoMutt->sub->notify, helpbar_config_observer, win_helpbar);
    notify_observer_remove(RootWindow->notify, helpbar_window_observer, win_helpbar);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

main_hist_observer()

int main_hist_observer

(

struct NotifyCallback *

nc

)

Notification that a Config Variable has change - Implements observer_t -.

Definition at line 701 of file history.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "history"))
    return 0;
 
  mutt_hist_init();
  mutt_debug(LL_DEBUG5, "history done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_timeout_observer()

static int imap_timeout_observer ( struct NotifyCallback * nc )

static

Notification that a timeout has occurred - Implements observer_t -.

This function is triggered by SIGWINCH.

Definition at line 43 of file adata.c.

{
  if (nc->event_type != NT_TIMEOUT)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct ImapAccountData *adata = nc->global_data;
  mutt_debug(LL_DEBUG5, "imap timeout start\n");
 
  time_t now = mutt_date_now();
  const short c_imap_keep_alive = cs_subset_number(NeoMutt->sub, "imap_keep_alive");
 
  if ((adata->state >= IMAP_AUTHENTICATED) && (now >= (adata->lastread + c_imap_keep_alive)))
  {
    mutt_debug(LL_DEBUG5, "imap_keep_alive\n");
    imap_check_mailbox(adata->mailbox, true);
  }
 
  mutt_debug(LL_DEBUG5, "imap timeout done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_mailbox_observer()

static int index_mailbox_observer ( struct NotifyCallback * nc )

static

Notification that a Mailbox has changed - Implements observer_t -.

If a Mailbox is closed, then set a pointer to NULL.

Definition at line 584 of file dlg_index.c.

{
  if (nc->event_type != NT_MAILBOX)
    return 0;
  if (!nc->global_data)
    return -1;
  if (nc->event_subtype != NT_MAILBOX_DELETE)
    return 0;
 
  struct Mailbox **ptr = nc->global_data;
  if (!*ptr)
    return 0;
 
  *ptr = NULL;
  mutt_debug(LL_DEBUG5, "mailbox done\n");
  return 0;
}

Here is the caller graph for this function:

ibar_color_observer()

static int ibar_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

Definition at line 168 of file ibar.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
 
  // MT_COLOR_MAX is sent on `uncolor *`
  if ((ev_c->cid != MT_COLOR_STATUS) && (ev_c->cid != MT_COLOR_NORMAL) &&
      (ev_c->cid != MT_COLOR_MAX))
  {
    return 0;
  }
 
  struct MuttWindow *win_ibar = nc->global_data;
  win_ibar->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT\n");
 
  return 0;
}

Here is the caller graph for this function:

ibar_config_observer()

static int ibar_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 194 of file ibar.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  if (!ev_c->name)
    return 0;
  if ((ev_c->name[0] != 's') && (ev_c->name[0] != 't'))
    return 0;
 
  if (!mutt_str_equal(ev_c->name, "status_format") &&
      !mutt_str_equal(ev_c->name, "ts_enabled") &&
      !mutt_str_equal(ev_c->name, "ts_icon_format") &&
      !mutt_str_equal(ev_c->name, "ts_status_format"))
  {
    return 0;
  }
 
  struct MuttWindow *win_ibar = nc->global_data;
  win_ibar->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ibar_index_observer()

static int ibar_index_observer ( struct NotifyCallback * nc )

static

Notification that the Index has changed - Implements observer_t -.

This function receives two sorts of notification:

• NT_INDEX: User has changed to a different Mailbox/Email
• NT_ACCOUNT/NT_MVIEW/NT_MAILBOX/NT_EMAIL: The state of an object has changed

Definition at line 231 of file ibar.c.

{
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win_ibar = nc->global_data;
  win_ibar->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "index done, request WA_RECALC\n");
 
  return 0;
}

Here is the caller graph for this function:

ibar_menu_observer()

static int ibar_menu_observer ( struct NotifyCallback * nc )

static

Notification that a Menu has changed - Implements observer_t -.

Definition at line 246 of file ibar.c.

{
  if (nc->event_type != NT_MENU)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win_ibar = nc->global_data;
  win_ibar->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "menu done, request WA_RECALC\n");
 
  return 0;
}

Here is the caller graph for this function:

ibar_window_observer()

static int ibar_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 263 of file ibar.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win_ibar = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_ibar)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    win_ibar->actions |= WA_REPAINT;
    mutt_debug(LL_DEBUG5, "window state done, request WA_REPAINT\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    struct MuttWindow *dlg = window_find_parent(win_ibar, WT_DLG_INDEX);
    struct IndexSharedData *shared = dlg->wdata;
 
    mutt_color_observer_remove(ibar_color_observer, win_ibar);
    notify_observer_remove(NeoMutt->sub->notify, ibar_config_observer, win_ibar);
    notify_observer_remove(shared->notify, ibar_index_observer, win_ibar);
    notify_observer_remove(win_ibar->parent->notify, ibar_menu_observer, win_ibar);
    notify_observer_remove(win_ibar->notify, ibar_window_observer, win_ibar);
 
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_altern_observer()

static int index_altern_observer ( struct NotifyCallback * nc )

static

Notification that an 'alternates' command has occurred - Implements observer_t -.

Definition at line 222 of file index.c.

{
  if (nc->event_type != NT_ALTERN)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct MuttWindow *dlg = dialog_find(win);
  struct IndexSharedData *shared = dlg->wdata;
 
  mutt_alternates_reset(shared->mailbox_view);
  mutt_debug(LL_DEBUG5, "alternates done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_attach_observer()

static int index_attach_observer ( struct NotifyCallback * nc )

static

Notification that an 'attachments' command has occurred - Implements observer_t -.

Definition at line 241 of file index.c.

{
  if (nc->event_type != NT_ATTACH)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct MuttWindow *dlg = dialog_find(win);
  struct IndexSharedData *shared = dlg->wdata;
 
  mutt_attachments_reset(shared->mailbox_view);
  mutt_debug(LL_DEBUG5, "attachments done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_color_observer()

static int index_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

Definition at line 260 of file index.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
 
  const int cid = ev_c->cid;
 
  // MT_COLOR_MAX is sent on `uncolor *`
  if (!((cid == MT_COLOR_INDEX) || (cid == MT_COLOR_INDEX_AUTHOR) ||
        (cid == MT_COLOR_INDEX_COLLAPSED) || (cid == MT_COLOR_INDEX_DATE) ||
        (cid == MT_COLOR_INDEX_FLAGS) || (cid == MT_COLOR_INDEX_LABEL) ||
        (cid == MT_COLOR_INDEX_NUMBER) || (cid == MT_COLOR_INDEX_SIZE) ||
        (cid == MT_COLOR_INDEX_SUBJECT) || (cid == MT_COLOR_INDEX_TAG) ||
        (cid == MT_COLOR_INDEX_TAGS) || (cid == MT_COLOR_MAX) ||
        (cid == MT_COLOR_NORMAL) || (cid == MT_COLOR_TREE)))
  {
    // The changes aren't relevant to the index menu
    return 0;
  }
 
  struct MuttWindow *win = nc->global_data;
  struct MuttWindow *dlg = dialog_find(win);
  struct IndexSharedData *shared = dlg->wdata;
 
  struct Mailbox *m = shared->mailbox;
  if (!m)
    return 0;
 
  // Force re-caching of index colours
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
    e->attr_color = NULL;
  }
 
  struct MuttWindow *panel_index = window_find_child(dlg, WT_INDEX);
  struct IndexPrivateData *priv = panel_index->wdata;
  struct Menu *menu = priv->menu;
  menu->redraw = MENU_REDRAW_FULL;
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "color done, request MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_config_observer()

static int index_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 385 of file index.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  if (!ev_c->name || !ev_c->he)
    return 0;
 
  struct MuttWindow *win = nc->global_data;
 
  if (!config_check_sort(ev_c->name) && !config_check_index(ev_c->name))
    return 0;
 
  if (mutt_str_equal(ev_c->name, "reply_regex"))
  {
    struct MuttWindow *dlg = dialog_find(win);
    struct IndexSharedData *shared = dlg->wdata;
    config_reply_regex(shared->mailbox_view);
    mutt_debug(LL_DEBUG5, "config done\n");
  }
  else if (mutt_str_equal(ev_c->name, "sort"))
  {
    config_sort(ev_c->sub);
    mutt_debug(LL_DEBUG5, "config done\n");
  }
  else if (mutt_str_equal(ev_c->name, "use_threads"))
  {
    config_use_threads(ev_c->sub);
    mutt_debug(LL_DEBUG5, "config done\n");
  }
  else if (mutt_str_equal(ev_c->name, "hide_thread_subject"))
  {
    struct MuttWindow *dlg = dialog_find(win);
    struct IndexSharedData *shared = dlg->wdata;
    mutt_sort_headers(shared->mailbox_view, false);
  }
 
  menu_queue_redraw(win->wdata, MENU_REDRAW_INDEX);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_global_observer()

static int index_global_observer ( struct NotifyCallback * nc )

static

Notification that a Global event occurred - Implements observer_t -.

Definition at line 432 of file index.c.

{
  if (nc->event_type != NT_GLOBAL)
    return 0;
  if (!nc->global_data)
    return -1;
  if (nc->event_subtype != NT_GLOBAL_COMMAND)
    return 0;
 
  struct MuttWindow *win = nc->global_data;
  struct MuttWindow *dlg = dialog_find(win);
  if (!dlg)
    return 0;
 
  struct IndexSharedData *shared = dlg->wdata;
  mutt_check_rescore(shared->mailbox);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_index_observer()

static int index_index_observer ( struct NotifyCallback * nc )

static

Notification that the Index has changed - Implements observer_t -.

Definition at line 455 of file index.c.

{
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  win->actions |= WA_RECALC;
 
  struct Menu *menu = win->wdata;
  menu_queue_redraw(menu, MENU_REDRAW_INDEX);
  mutt_debug(LL_DEBUG5, "index done, request WA_RECALC\n");
 
  struct IndexPrivateData *priv = menu->mdata;
  struct IndexSharedData *shared = priv->shared;
  if (shared && shared->mailbox)
    menu->max = shared->mailbox->vcount;
  else
    menu->max = 0;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_menu_observer()

static int index_menu_observer ( struct NotifyCallback * nc )

static

Notification that the Menu has changed - Implements observer_t -.

Definition at line 480 of file index.c.

{
  if (nc->event_type != NT_MENU)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct MuttWindow *dlg = dialog_find(win);
  struct IndexSharedData *shared = dlg->wdata;
  struct Menu *menu = win->wdata;
 
  const int index = menu_get_index(menu);
  struct Email *e = mutt_get_virt_email(shared->mailbox, index);
  index_shared_data_set_email(shared, e);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_score_observer()

static int index_score_observer ( struct NotifyCallback * nc )

static

Notification that a 'score' command has occurred - Implements observer_t -.

Definition at line 502 of file index.c.

{
  if (nc->event_type != NT_SCORE)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct MuttWindow *dlg = dialog_find(win);
  struct IndexSharedData *shared = dlg->wdata;
 
  struct Mailbox *m = shared->mailbox;
  if (!m)
    return 0;
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    mutt_score_message(m, e, true);
    e->attr_color = NULL; // Force recalc of colour
  }
 
  mutt_debug(LL_DEBUG5, "score done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_subjrx_observer()

static int index_subjrx_observer ( struct NotifyCallback * nc )

static

Notification that a 'subjectrx' command has occurred - Implements observer_t -.

Definition at line 534 of file index.c.

{
  if (nc->event_type != NT_SUBJRX)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct MuttWindow *dlg = dialog_find(win);
  struct IndexSharedData *shared = dlg->wdata;
 
  subjrx_clear_mods(shared->mailbox_view);
  mutt_debug(LL_DEBUG5, "subjectrx done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_window_observer()

static int index_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 553 of file index.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct Menu *menu = win->wdata;
  if (nc->event_subtype != NT_WINDOW_DELETE)
  {
    if (nc->event_subtype != NT_WINDOW_FOCUS)
      menu_queue_redraw(menu, MENU_REDRAW_FULL | MENU_REDRAW_INDEX);
    return 0;
  }
 
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win)
    return 0;
 
  struct IndexPrivateData *priv = menu->mdata;
 
  mutt_color_observer_remove(index_color_observer, win);
  notify_observer_remove(NeoMutt->notify, index_altern_observer, win);
  notify_observer_remove(NeoMutt->notify, index_attach_observer, win);
  notify_observer_remove(NeoMutt->sub->notify, index_config_observer, win);
  notify_observer_remove(NeoMutt->notify, index_global_observer, win);
  notify_observer_remove(priv->shared->notify, index_index_observer, win);
  notify_observer_remove(menu->notify, index_menu_observer, win);
  notify_observer_remove(NeoMutt->notify, index_score_observer, win);
  notify_observer_remove(NeoMutt->notify, index_subjrx_observer, win);
  notify_observer_remove(win->notify, index_window_observer, win);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ipanel_config_observer()

static int ipanel_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 72 of file ipanel.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  struct MuttWindow *panel_index = nc->global_data;
 
  if (mutt_str_equal(ev_c->name, "status_on_top"))
  {
    window_status_on_top(panel_index, NeoMutt->sub);
    mutt_debug(LL_DEBUG5, "config done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ipanel_window_observer()

static int ipanel_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 94 of file ipanel.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *panel_index = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != panel_index)
    return 0;
 
  notify_observer_remove(NeoMutt->sub->notify, ipanel_config_observer, panel_index);
  notify_observer_remove(panel_index->notify, ipanel_window_observer, panel_index);
  mutt_debug(LL_DEBUG5, "window delete done\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_shared_mview_observer()

static int index_shared_mview_observer ( struct NotifyCallback * nc )

static

Notification that the MailboxView has changed - Implements observer_t -.

Definition at line 43 of file shared_data.c.

{
  if (nc->event_type != NT_MVIEW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype == NT_MVIEW_ADD)
    return 0;
 
  struct EventMview *ev_m = nc->event_data;
  struct IndexSharedData *shared = nc->global_data;
  if (ev_m->mv != shared->mailbox_view)
    return 0;
 
  if (nc->event_subtype == NT_MVIEW_DELETE)
    shared->mailbox_view = NULL;
 
  mutt_debug(LL_NOTIFY, "relay NT_MVIEW to shared data observers\n");
  notify_send(shared->notify, nc->event_type, nc->event_subtype, nc->event_data);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_shared_account_observer()

static int index_shared_account_observer ( struct NotifyCallback * nc )

static

Notification that an Account has changed - Implements observer_t -.

Definition at line 68 of file shared_data.c.

{
  if (nc->event_type != NT_ACCOUNT)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype == NT_ACCOUNT_ADD)
    return 0;
 
  struct EventAccount *ev_a = nc->event_data;
  struct IndexSharedData *shared = nc->global_data;
  if (ev_a->account != shared->account)
    return 0;
 
  if (nc->event_subtype == NT_ACCOUNT_DELETE)
    shared->account = NULL;
 
  mutt_debug(LL_NOTIFY, "relay NT_ACCOUNT to shared data observers\n");
  notify_send(shared->notify, nc->event_type, nc->event_subtype, nc->event_data);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_shared_mailbox_observer()

static int index_shared_mailbox_observer ( struct NotifyCallback * nc )

static

Notification that a Mailbox has changed - Implements observer_t -.

Definition at line 93 of file shared_data.c.

{
  if (nc->event_type != NT_MAILBOX)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype == NT_MAILBOX_ADD)
    return 0;
 
  struct EventMailbox *ev_m = nc->event_data;
  struct IndexSharedData *shared = nc->global_data;
  if (ev_m->mailbox != shared->mailbox)
    return 0;
 
  if (nc->event_subtype == NT_MAILBOX_DELETE)
    shared->mailbox = NULL;
 
  mutt_debug(LL_NOTIFY, "relay NT_MAILBOX to shared data observers\n");
  notify_send(shared->notify, nc->event_type, nc->event_subtype, nc->event_data);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_shared_email_observer()

static int index_shared_email_observer ( struct NotifyCallback * nc )

static

Notification that an Email has changed - Implements observer_t -.

Definition at line 118 of file shared_data.c.

{
  if (nc->event_type != NT_EMAIL)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype == NT_EMAIL_ADD)
    return 0;
 
  struct EventEmail *ev_e = nc->event_data;
  struct IndexSharedData *shared = nc->global_data;
  bool match = false;
  for (int i = 0; i < ev_e->num_emails; i++)
  {
    if (ev_e->emails[i] == shared->email)
    {
      match = true;
      break;
    }
  }
 
  if (!match)
    return 0;
 
  if (nc->event_subtype == NT_EMAIL_DELETE)
  {
    shared->email = NULL;
    mutt_debug(LL_NOTIFY, "NT_INDEX_EMAIL: %p\n", (void *) shared->email);
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, shared);
  }
 
  mutt_debug(LL_NOTIFY, "relay NT_EMAIL %p to shared data observers\n",
             (void *) shared->email);
  notify_send(shared->notify, nc->event_type, nc->event_subtype, nc->event_data);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

key_config_observer()

int key_config_observer

(

struct NotifyCallback *

nc

)

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 126 of file init.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "abort_key"))
    return 0;
 
  mutt_init_abort_key();
  mutt_debug(LL_DEBUG5, "config done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

main_timeout_observer()

static int main_timeout_observer ( struct NotifyCallback * nc )

static

Notification that a timeout has occurred - Implements observer_t -.

Definition at line 909 of file main.c.

{
  static time_t last_run = 0;
 
  if (nc->event_type != NT_TIMEOUT)
    return 0;
 
  const short c_timeout = cs_subset_number(NeoMutt->sub, "timeout");
  if (c_timeout <= 0)
    goto done;
 
  time_t now = mutt_date_now();
  if (now < (last_run + c_timeout))
    goto done;
 
  // Limit hook to running under the Index or Pager
  struct MuttWindow *focus = window_get_focus();
  struct MuttWindow *dlg = dialog_find(focus);
  if (!dlg || (dlg->type != WT_DLG_INDEX))
    goto done;
 
  last_run = now;
  mutt_timeout_hook();
 
done:
  mutt_debug(LL_DEBUG5, "timeout done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_color_observer()

static int menu_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

Definition at line 41 of file observer.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
 
  // MT_COLOR_MAX is sent on `uncolor *`
  if ((ev_c->cid != MT_COLOR_NORMAL) && (ev_c->cid != MT_COLOR_INDICATOR) &&
      (ev_c->cid != MT_COLOR_MAX))
  {
    return 0;
  }
 
  struct Menu *menu = nc->global_data;
  struct MuttWindow *win = menu->win;
 
  menu->redraw = MENU_REDRAW_FULL;
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the caller graph for this function:

menu_config_observer()

static int menu_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 70 of file observer.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  if (!mutt_str_startswith(ev_c->name, "arrow_") && !mutt_str_startswith(ev_c->name, "menu_"))
    return 0;
 
  if (mutt_str_equal(ev_c->name, "menu_scroll"))
    return 0; // This doesn't affect the display
 
  struct Menu *menu = nc->global_data;
  menu_adjust(menu);
 
  menu->redraw |= MENU_REDRAW_FULL;
  menu->win->actions |= WA_RECALC;
 
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC, MENU_REDRAW_FULL\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_window_observer()

static int menu_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 97 of file observer.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct Menu *menu = nc->global_data;
  struct MuttWindow *win = menu->win;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    menu->page_len = win->state.rows;
    menu->redraw |= MENU_REDRAW_FULL;
 
    win->actions |= WA_RECALC | WA_REPAINT;
    mutt_debug(LL_DEBUG5, "window state done, request MENU_REDRAW_INDEX, WA_REPAINT\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    notify_observer_remove(NeoMutt->sub->notify, menu_config_observer, menu);
    notify_observer_remove(win->notify, menu_window_observer, menu);
    mutt_color_observer_remove(menu_color_observer, menu);
    msgwin_clear_text(NULL);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

main_log_observer()

int main_log_observer

(

struct NotifyCallback *

nc

)

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 284 of file mutt_logging.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (mutt_str_equal(ev_c->name, "debug_file"))
  {
    const char *const c_debug_file = cs_subset_path(NeoMutt->sub, "debug_file");
    mutt_log_set_file(c_debug_file);
  }
  else if (mutt_str_equal(ev_c->name, "debug_level"))
  {
    const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
    mutt_log_set_level(c_debug_level, true);
  }
  else
  {
    return 0;
  }
 
  mutt_debug(LL_DEBUG5, "log done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mview_mailbox_observer()

int mview_mailbox_observer

(

struct NotifyCallback *

nc

)

Notification that a Mailbox has changed - Implements observer_t -.

Definition at line 324 of file mview.c.

{
  if (nc->event_type != NT_MAILBOX)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MailboxView *mv = nc->global_data;
 
  switch (nc->event_subtype)
  {
    case NT_MAILBOX_DELETE:
      mutt_clear_threads(mv->threads);
      mview_clean(mv);
      break;
    case NT_MAILBOX_INVALID:
      mview_update(mv);
      break;
    case NT_MAILBOX_UPDATE:
      update_tables(mv);
      break;
    case NT_MAILBOX_RESORT:
      mutt_sort_headers(mv, true);
      break;
    default:
      return 0;
  }
 
  mutt_debug(LL_DEBUG5, "mailbox done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gpgme_key_config_observer()

static int gpgme_key_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 131 of file dlg_gpgme.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "pgp_entry_format") &&
      !mutt_str_equal(ev_c->name, "pgp_key_sort"))
  {
    return 0;
  }
 
  struct Menu *menu = nc->global_data;
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gpgme_key_window_observer()

static int gpgme_key_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Help Bar

Definition at line 160 of file dlg_gpgme.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_menu = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_menu)
    return 0;
 
  struct Menu *menu = win_menu->wdata;
 
  notify_observer_remove(NeoMutt->sub->notify, gpgme_key_config_observer, menu);
  notify_observer_remove(win_menu->notify, gpgme_key_window_observer, win_menu);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_key_config_observer()

static int pgp_key_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 130 of file dlg_pgp.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "pgp_entry_format") &&
      !mutt_str_equal(ev_c->name, "pgp_key_sort"))
  {
    return 0;
  }
 
  struct Menu *menu = nc->global_data;
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_key_window_observer()

static int pgp_key_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Help Bar

Definition at line 159 of file dlg_pgp.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_menu = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_menu)
    return 0;
 
  struct Menu *menu = win_menu->wdata;
 
  notify_observer_remove(NeoMutt->sub->notify, pgp_key_config_observer, menu);
  notify_observer_remove(win_menu->notify, pgp_key_window_observer, win_menu);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dopager_config_observer()

static int dopager_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 74 of file do_pager.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  if (!mutt_str_equal(ev_c->name, "status_on_top"))
    return 0;
 
  struct MuttWindow *dlg = nc->global_data;
  window_status_on_top(dlg, NeoMutt->sub);
  mutt_debug(LL_DEBUG5, "config done, request WA_REFLOW\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dopager_window_observer()

static int dopager_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 94 of file do_pager.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *dlg = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != dlg)
    return 0;
 
  notify_observer_remove(NeoMutt->sub->notify, dopager_config_observer, dlg);
  notify_observer_remove(dlg->notify, dopager_window_observer, dlg);
  mutt_debug(LL_DEBUG5, "window delete done\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pager_color_observer()

static int pager_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

Definition at line 240 of file pager.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
  struct MuttWindow *win_pager = nc->global_data;
  struct PagerPrivateData *priv = win_pager->wdata;
  if (!priv)
    return 0;
 
  // MT_COLOR_MAX is sent on `uncolor *`
  if (COLOR_QUOTED(ev_c->cid) || (ev_c->cid == MT_COLOR_MAX))
  {
    // rework quoted colours
    qstyle_recolor(priv->quote_list);
  }
 
  if (ev_c->cid == MT_COLOR_MAX)
  {
    for (size_t i = 0; i < priv->lines_max; i++)
    {
      FREE(&(priv->lines[i].syntax));
    }
    priv->lines_used = 0;
  }
  else if ((ev_c->cid == MT_COLOR_ATTACHMENT) || (ev_c->cid == MT_COLOR_ATTACH_HEADERS) ||
           (ev_c->cid == MT_COLOR_BODY) || (ev_c->cid == MT_COLOR_BOLD) ||
           (ev_c->cid == MT_COLOR_ERROR) || (ev_c->cid == MT_COLOR_HDRDEFAULT) ||
           (ev_c->cid == MT_COLOR_HEADER) || (ev_c->cid == MT_COLOR_ITALIC) ||
           (ev_c->cid == MT_COLOR_MARKERS) || (ev_c->cid == MT_COLOR_MESSAGE) ||
           (ev_c->cid == MT_COLOR_NORMAL) || (ev_c->cid == MT_COLOR_SEARCH) ||
           (ev_c->cid == MT_COLOR_SIGNATURE) || (ev_c->cid == MT_COLOR_STRIPE_EVEN) ||
           (ev_c->cid == MT_COLOR_STRIPE_ODD) || (ev_c->cid == MT_COLOR_TILDE) ||
           (ev_c->cid == MT_COLOR_UNDERLINE) || (ev_c->cid == MT_COLOR_WARNING))
  {
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  }
 
  mutt_debug(LL_DEBUG5, "color done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pager_config_observer()

static int pager_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 288 of file pager.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  struct MuttWindow *win_pager = nc->global_data;
 
  if (mutt_str_equal(ev_c->name, "pager_index_lines"))
  {
    config_pager_index_lines(win_pager);
    mutt_debug(LL_DEBUG5, "config done\n");
  }
  else if ((mutt_str_equal(ev_c->name, "allow_ansi")) ||
           (mutt_str_equal(ev_c->name, "markers")) ||
           (mutt_str_equal(ev_c->name, "smart_wrap")) ||
           (mutt_str_equal(ev_c->name, "smileys")) ||
           (mutt_str_equal(ev_c->name, "tilde")) ||
           (mutt_str_equal(ev_c->name, "toggle_quoted_show_levels")) ||
           (mutt_str_equal(ev_c->name, "wrap")))
  {
    struct PagerPrivateData *priv = win_pager->parent->wdata;
    if (!priv)
      return -1;
 
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pager_index_observer()

static int pager_index_observer ( struct NotifyCallback * nc )

static

Notification that the Index has changed - Implements observer_t -.

Definition at line 324 of file pager.c.

{
  if (nc->event_type != NT_INDEX)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win_pager = nc->global_data;
 
  struct PagerPrivateData *priv = win_pager->wdata;
  if (!priv)
    return 0;
 
  struct IndexSharedData *shared = nc->event_data;
 
  if (nc->event_subtype & NT_INDEX_MAILBOX)
  {
    win_pager->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "index done, request WA_RECALC\n");
    priv->loop = PAGER_LOOP_QUIT;
  }
  else if (nc->event_subtype & NT_INDEX_EMAIL)
  {
    win_pager->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "index done, request WA_RECALC\n");
    priv->pager_redraw = true;
    if (shared && shared->email && (priv->loop != PAGER_LOOP_QUIT))
    {
      priv->loop = PAGER_LOOP_RELOAD;
    }
    else
    {
      priv->loop = PAGER_LOOP_QUIT;
      priv->rc = 0;
    }
  }
 
  return 0;
}

Here is the caller graph for this function:

pager_pager_observer()

static int pager_pager_observer ( struct NotifyCallback * nc )

static

Notification that the Pager has changed - Implements observer_t -.

Definition at line 367 of file pager.c.

{
  if (nc->event_type != NT_PAGER)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win_pager = nc->global_data;
 
  struct PagerPrivateData *priv = win_pager->wdata;
  if (!priv)
    return 0;
 
  pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
  mutt_debug(LL_DEBUG5, "pager done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pager_window_observer()

static int pager_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 388 of file pager.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_pager = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_pager)
    return 0;
 
  struct PagerPrivateData *priv = win_pager->wdata;
  if (!priv)
    return 0;
 
  struct MuttWindow *dlg = window_find_parent(win_pager, WT_DLG_INDEX);
  if (!dlg)
    dlg = window_find_parent(win_pager, WT_DLG_PAGER);
 
  struct IndexSharedData *shared = dlg->wdata;
 
  mutt_color_observer_remove(pager_color_observer, win_pager);
  notify_observer_remove(NeoMutt->sub->notify, pager_config_observer, win_pager);
  notify_observer_remove(shared->notify, pager_index_observer, win_pager);
  notify_observer_remove(priv->notify, pager_pager_observer, win_pager);
  notify_observer_remove(win_pager->notify, pager_window_observer, win_pager);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pbar_color_observer()

static int pbar_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

Definition at line 172 of file pbar.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
  enum ColorId cid = ev_c->cid;
 
  if ((cid != MT_COLOR_STATUS) && (cid != MT_COLOR_NORMAL) && (cid != MT_COLOR_MAX))
    return 0;
 
  struct MuttWindow *win_pbar = nc->global_data;
  win_pbar->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT\n");
 
  return 0;
}

Here is the caller graph for this function:

pbar_config_observer()

static int pbar_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 195 of file pbar.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  if (!mutt_str_equal(ev_c->name, "pager_format"))
    return 0;
 
  struct MuttWindow *win_pbar = nc->global_data;
  win_pbar->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pbar_index_observer()

static int pbar_index_observer ( struct NotifyCallback * nc )

static

Notification that the Index has changed - Implements observer_t -.

This function receives two sorts of notification:

• NT_INDEX: User has changed to a different Mailbox/Email
• NT_CONTEXT/NT_ACCOUNT/NT_MAILBOX/NT_EMAIL: The state of an object has changed

Definition at line 222 of file pbar.c.

{
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win_pbar = nc->global_data;
  win_pbar->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "index done, request WA_RECALC\n");
 
  return 0;
}

Here is the caller graph for this function:

pbar_pager_observer()

static int pbar_pager_observer ( struct NotifyCallback * nc )

static

Notification that the Pager has changed - Implements observer_t -.

Definition at line 237 of file pbar.c.

{
  if (nc->event_type != NT_PAGER)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win_pbar = nc->global_data;
 
  if (nc->event_subtype & NT_PAGER_VIEW)
  {
    win_pbar->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "pager done, request WA_RECALC\n");
  }
 
  return 0;
}

Here is the caller graph for this function:

pbar_window_observer()

static int pbar_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 258 of file pbar.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win_pbar = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_pbar)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    win_pbar->actions |= WA_RECALC | WA_REPAINT;
    mutt_debug(LL_NOTIFY, "window state done, request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    struct PBarPrivateData *pbar_data = win_pbar->wdata;
    struct IndexSharedData *shared = pbar_data->shared;
 
    mutt_color_observer_remove(pbar_color_observer, win_pbar);
    notify_observer_remove(NeoMutt->sub->notify, pbar_config_observer, win_pbar);
    notify_observer_remove(shared->notify, pbar_index_observer, win_pbar);
    notify_observer_remove(pbar_data->priv->notify, pbar_pager_observer, win_pbar);
    notify_observer_remove(win_pbar->notify, pbar_window_observer, win_pbar);
 
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ppanel_config_observer()

static int ppanel_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 72 of file ppanel.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
  struct MuttWindow *panel_pager = nc->global_data;
 
  if (mutt_str_equal(ev_c->name, "status_on_top"))
  {
    window_status_on_top(panel_pager, NeoMutt->sub);
    mutt_debug(LL_DEBUG5, "config done\n");
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ppanel_window_observer()

static int ppanel_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 94 of file ppanel.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *panel_pager = nc->global_data;
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    panel_pager->actions |= WA_RECALC | WA_REPAINT;
 
    struct PagerPrivateData *priv = panel_pager->wdata;
    if (priv->pview)
      pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
 
    mutt_debug(LL_NOTIFY, "window state done, request WA_RECALC\n");
  }
 
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != panel_pager)
    return 0;
 
  notify_observer_remove(NeoMutt->sub->notify, ppanel_config_observer, panel_pager);
  notify_observer_remove(panel_pager->notify, ppanel_window_observer, panel_pager);
  mutt_debug(LL_DEBUG5, "window delete done\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pattern_config_observer()

static int pattern_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

The Address Book Window is affected by changes to $sort_pattern.

Definition at line 225 of file dlg_pattern.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "pattern_format"))
    return 0;
 
  struct Menu *menu = nc->global_data;
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pattern_window_observer()

static int pattern_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Help Bar

Definition at line 251 of file dlg_pattern.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_menu = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_menu)
    return 0;
 
  struct Menu *menu = win_menu->wdata;
 
  notify_observer_remove(NeoMutt->sub->notify, pattern_config_observer, menu);
  notify_observer_remove(win_menu->notify, pattern_window_observer, win_menu);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

postponed_config_observer()

static int postponed_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

The Address Book Window is affected by changes to $sort_postponed.

Definition at line 126 of file dlg_postpone.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "index_format") && !mutt_str_equal(ev_c->name, "sort"))
    return 0;
 
  struct Menu *menu = nc->global_data;
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC, MENU_REDRAW_FULL\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

postponed_window_observer()

static int postponed_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

This function is triggered by changes to the windows.

• Delete (this window): clean up the resources held by the Help Bar

Definition at line 152 of file dlg_postpone.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DELETE)
    return 0;
 
  struct MuttWindow *win_menu = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win_menu)
    return 0;
 
  struct Menu *menu = win_menu->wdata;
 
  notify_observer_remove(NeoMutt->sub->notify, postponed_config_observer, menu);
  notify_observer_remove(win_menu->notify, postponed_window_observer, win_menu);
 
  mutt_debug(LL_DEBUG5, "window delete done\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_account_observer()

static int sb_account_observer ( struct NotifyCallback * nc )

static

Notification that an Account has changed - Implements observer_t -.

Definition at line 173 of file observer.c.

{
  if (nc->event_type != NT_ACCOUNT)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
  if (nc->event_subtype == NT_ACCOUNT_DELETE)
    return 0;
 
  struct MuttWindow *win = nc->global_data;
  struct SidebarWindowData *wdata = sb_wdata_get(win);
  struct EventAccount *ev_a = nc->event_data;
 
  struct MailboxNode *np = NULL;
  STAILQ_FOREACH(np, &ev_a->account->mailboxes, entries)
  {
    sb_add_mailbox(wdata, np->mailbox);
  }
 
  win->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "account done, request WA_RECALC\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_color_observer()

static int sb_color_observer ( struct NotifyCallback * nc )

static

Notification that a Color has changed - Implements observer_t -.

Definition at line 200 of file observer.c.

{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
  struct MuttWindow *win = nc->global_data;
 
  enum ColorId cid = ev_c->cid;
 
  if (cid == MT_COLOR_MAX) // Sent on `uncolor *`
  {
    // Set a default style
    struct AttrColor *ac = simple_color_get(MT_COLOR_SIDEBAR_HIGHLIGHT);
    ac->attrs = A_UNDERLINE;
  }
 
  switch (cid)
  {
    case MT_COLOR_INDICATOR:
    case MT_COLOR_NORMAL:
    case MT_COLOR_SIDEBAR_BACKGROUND:
    case MT_COLOR_SIDEBAR_DIVIDER:
    case MT_COLOR_SIDEBAR_FLAGGED:
    case MT_COLOR_SIDEBAR_HIGHLIGHT:
    case MT_COLOR_SIDEBAR_INDICATOR:
    case MT_COLOR_SIDEBAR_NEW:
    case MT_COLOR_SIDEBAR_ORDINARY:
    case MT_COLOR_SIDEBAR_SPOOLFILE:
    case MT_COLOR_SIDEBAR_UNREAD:
    case MT_COLOR_MAX: // Sent on `uncolor *`
      win->actions |= WA_REPAINT;
      mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT\n");
      break;
 
    default:
      break;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_command_observer()

static int sb_command_observer ( struct NotifyCallback * nc )

static

Notification that a Command has occurred - Implements observer_t -.

Definition at line 246 of file observer.c.

{
  if (nc->event_type != NT_COMMAND)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct Command *cmd = nc->event_data;
 
  if ((cmd->parse != sb_parse_sidebar_pin) && (cmd->parse != sb_parse_sidebar_unpin))
    return 0;
 
  struct MuttWindow *win = nc->global_data;
  win->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "command done, request WA_RECALC\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_config_observer()

static int sb_config_observer ( struct NotifyCallback * nc )

static

Notification that a Config Variable has changed - Implements observer_t -.

Definition at line 267 of file observer.c.

{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_strn_equal(ev_c->name, "sidebar_", 8) &&
      !mutt_str_equal(ev_c->name, "ascii_chars") &&
      !mutt_str_equal(ev_c->name, "folder") && !mutt_str_equal(ev_c->name, "spool_file"))
  {
    return 0;
  }
 
  if (mutt_str_equal(ev_c->name, "sidebar_next_new_wrap"))
    return 0; // Affects the behaviour, but not the display
 
  mutt_debug(LL_DEBUG5, "config: %s\n", ev_c->name);
 
  struct MuttWindow *win = nc->global_data;
 
  if (mutt_str_equal(ev_c->name, "sidebar_visible"))
  {
    const bool c_sidebar_visible = cs_subset_bool(NeoMutt->sub, "sidebar_visible");
    window_set_visible(win, c_sidebar_visible);
    window_reflow(win->parent);
    mutt_debug(LL_DEBUG5, "config done, request WA_REFLOW\n");
    return 0;
  }
 
  if (mutt_str_equal(ev_c->name, "sidebar_width"))
  {
    const short c_sidebar_width = cs_subset_number(NeoMutt->sub, "sidebar_width");
    win->req_cols = c_sidebar_width;
    window_reflow(win->parent);
    mutt_debug(LL_DEBUG5, "config done, request WA_REFLOW\n");
    return 0;
  }
 
  if (mutt_str_equal(ev_c->name, "spool_file"))
  {
    win->actions |= WA_REPAINT;
    mutt_debug(LL_DEBUG5, "config done, request WA_REPAINT\n");
    return 0;
  }
 
  if (mutt_str_equal(ev_c->name, "sidebar_on_right"))
  {
    struct MuttWindow *parent = win->parent;
    struct MuttWindow *first = TAILQ_FIRST(&parent->children);
    const bool c_sidebar_on_right = cs_subset_bool(NeoMutt->sub, "sidebar_on_right");
 
    if ((c_sidebar_on_right && (first == win)) || (!c_sidebar_on_right && (first != win)))
    {
      // Swap the Sidebar and the Container of the Index/Pager
      TAILQ_REMOVE(&parent->children, first, entries);
      TAILQ_INSERT_TAIL(&parent->children, first, entries);
    }
 
    window_reflow(win->parent);
    mutt_debug(LL_DEBUG5, "config done, request WA_REFLOW\n");
    return 0;
  }
 
  if (mutt_str_equal(ev_c->name, "ascii_chars") ||
      mutt_str_equal(ev_c->name, "sidebar_divider_char"))
  {
    struct SidebarWindowData *wdata = sb_wdata_get(win);
    calc_divider(wdata);
    win->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "config done, request WA_RECALC\n");
    return 0;
  }
 
  // All the remaining config changes...
  win->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "config done, request WA_RECALC\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_index_observer()

static int sb_index_observer ( struct NotifyCallback * nc )

static

Notification that the Index has changed - Implements observer_t -.

Definition at line 352 of file observer.c.

{
  if (nc->event_type != NT_INDEX)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return 0;
  if (!(nc->event_subtype & NT_INDEX_MAILBOX))
    return 0;
 
  struct MuttWindow *win_sidebar = nc->global_data;
  struct IndexSharedData *shared = nc->event_data;
 
  struct SidebarWindowData *wdata = sb_wdata_get(win_sidebar);
  sb_set_current_mailbox(wdata, shared->mailbox);
 
  win_sidebar->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "index done, request WA_RECALC\n");
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_mailbox_observer()

static int sb_mailbox_observer ( struct NotifyCallback * nc )

static

Notification that a Mailbox has changed - Implements observer_t -.

Definition at line 376 of file observer.c.

{
  if (nc->event_type != NT_MAILBOX)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
 
  struct SidebarWindowData *wdata = sb_wdata_get(win);
  struct EventMailbox *ev_m = nc->event_data;
 
  if (nc->event_subtype == NT_MAILBOX_ADD)
  {
    sb_add_mailbox(wdata, ev_m->mailbox);
  }
  else if (nc->event_subtype == NT_MAILBOX_DELETE)
  {
    sb_remove_mailbox(wdata, ev_m->mailbox);
  }
 
  win->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "mailbox done, request WA_RECALC\n");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_window_observer()

static int sb_window_observer ( struct NotifyCallback * nc )

static

Notification that a Window has changed - Implements observer_t -.

Definition at line 405 of file observer.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    win->actions |= WA_RECALC;
    mutt_debug(LL_DEBUG5, "window state done, request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    mutt_debug(LL_DEBUG5, "window delete done\n");
    sb_win_remove_observers(win);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_insertion_window_observer()

int sb_insertion_window_observer

(

struct NotifyCallback *

nc

)

Notification that a Window has changed - Implements observer_t -.

Definition at line 473 of file observer.c.

{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->event_data)
    return -1;
  if (nc->event_subtype != NT_WINDOW_DIALOG)
    return 0;
 
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win->type != WT_DLG_INDEX)
    return 0;
 
  if (ev_w->flags & WN_VISIBLE)
  {
    mutt_debug(LL_DEBUG5, "insertion: visible\n");
    struct MuttWindow *win_sidebar = sb_win_init(ev_w->win);
    sb_init_data(win_sidebar);
  }
  else if (ev_w->flags & WN_HIDDEN)
  {
    mutt_debug(LL_DEBUG5, "insertion: hidden\n");
    sb_win_remove_observers(ev_w->win);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: