Function Dispatcher API

Prototype for a Function Dispatcher. More...

Collaboration diagram for Function Dispatcher API:

Topics
	Alias Function API
	Prototype for a Alias Function.
	Attach Function API
	Prototype for a Attach Function.
	Autocrypt Function API
	Prototype for a Autocrypt Function.
	Compose Function API
	Prototype for a Compose Function.
	Preview Function API
	Prototype for a Preview Function.
	Envelope Function API
	Prototype for a Envelope Function.
	Global Function API
	Prototype for a Global Function.
	History Function API
	Prototype for a History Function.
	Index Function API
	Prototype for an Index Function.
	Menu Function API
	Prototype for a Menu Function.
	Mailing-list Function API
	Prototype for a Mailing-list Function.
	Gpgme Function API
	Prototype for a Gpgme Function.
	Pgp Function API
	Prototype for a Pgp Function.
	Smime Function API
	Prototype for a Smime Function.
	Pager Function API
	Prototype for a Pager Function.
	Pattern Function API
	Prototype for a Pattern Function.
	Postpone Function API
	Prototype for a Postpone Function.
	Sidebar Function API
	Prototype for a Sidebar Function.

Functions
int	alias_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Alias function - Implements function_dispatcher_t -.
int	attach_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Attach function - Implements function_dispatcher_t -.
int	autocrypt_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Autocrypt function - Implements function_dispatcher_t -.
int	compose_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Compose function - Implements function_dispatcher_t -.
int	preview_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a preview function - Implements function_dispatcher_t -.
int	enter_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform an Enter function - Implements function_dispatcher_t -.
int	env_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform an Envelope function - Implements function_dispatcher_t -.
int	global_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Global function - Implements function_dispatcher_t -.
int	history_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a History function - Implements function_dispatcher_t -.
int	index_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform an Index function - Implements function_dispatcher_t -.
int	menu_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Menu function - Implements function_dispatcher_t -.
int	menu_tagging_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform tagging operations on the Menu - Implements function_dispatcher_t -.
int	mlist_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a List dialog function - Implements function_dispatcher_t -.
int	gpgme_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Gpgme function - Implements function_dispatcher_t -.
int	pgp_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Pgp function - Implements function_dispatcher_t -.
int	smime_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Smime function - Implements function_dispatcher_t -.
int	pager_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Pager function - Implements function_dispatcher_t -.
int	pattern_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Pattern function - Implements function_dispatcher_t -.
int	postpone_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Postpone function - Implements function_dispatcher_t -.
int	sb_fuzzy_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Fuzzy Search function - Implements function_dispatcher_t -.
int	sb_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Sidebar function - Implements function_dispatcher_t -.

Detailed Description

Prototype for a Function Dispatcher.

Perform a NeoMutt function

Parameters

win	Window
event	Event to act upon

Return values

num	FunctionRetval

Function Documentation

alias_function_dispatcher()

int alias_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Alias function - Implements function_dispatcher_t -.

Definition at line 637 of file functions.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
    return FR_ERROR;
 
  struct Menu *menu = dlg->wdata;
  struct AliasMenuData *mdata = menu->mdata;
  if (!mdata)
    return FR_ERROR;
 
  const int op = event->op;
 
  struct AliasFunctionData fdata = {
    .n = NeoMutt,
    .wdata = mdata,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; AliasFunctions[i].op != OP_NULL; i++)
  {
    const struct AliasFunction *fn = &AliasFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_function_dispatcher()

int attach_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Attach function - Implements function_dispatcher_t -.

Definition at line 818 of file functions.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  struct Menu *menu = dlg->wdata;
  struct AttachPrivateData *priv = menu->mdata;
  if (!priv)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
 
  struct AttachFunctionData fdata = {
    .n = NeoMutt,
    .priv = priv,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; AttachFunctions[i].op != OP_NULL; i++)
  {
    const struct AttachFunction *fn = &AttachFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

autocrypt_function_dispatcher()

int autocrypt_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Autocrypt function - Implements function_dispatcher_t -.

Definition at line 238 of file functions.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
  struct Menu *menu = dlg->wdata;
  struct AutocryptData *ad = menu->mdata;
  if (!ad)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; AutocryptFunctions[i].op != OP_NULL; i++)
  {
    const struct AutocryptFunction *fn = &AutocryptFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(ad, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compose_function_dispatcher()

int compose_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Compose function - Implements function_dispatcher_t -.

Definition at line 2781 of file functions.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
 
  struct ComposeModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_COMPOSE);
 
  struct ComposeFunctionData fdata = {
    .n = NeoMutt,
    .mod_data = mod_data,
    .shared = dlg->wdata,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; ComposeFunctions[i].op != OP_NULL; i++)
  {
    const struct ComposeFunction *fn = &ComposeFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

preview_function_dispatcher()

int preview_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a preview function - Implements function_dispatcher_t -.

Definition at line 569 of file preview.c.

{
  if (!event || !win || !win->wdata)
    return FR_UNKNOWN;
 
  const int op = event->op;
  int rc = FR_UNKNOWN;
  for (size_t i = 0; PreviewFunctions[i].op != OP_NULL; i++)
  {
    const struct PreviewFunction *fn = &PreviewFunctions[i];
    if (fn->op == op)
    {
      struct PreviewWindowData *wdata = win->wdata;
      rc = fn->function(wdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

enter_function_dispatcher()

int enter_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform an Enter function - Implements function_dispatcher_t -.

Definition at line 535 of file functions.c.

{
  if (!event || !win || !win->wdata)
    return FR_UNKNOWN;
 
  const int op = event->op;
 
  struct EditorModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EDITOR);
 
  struct EnterFunctionData fdata = {
    .n = NeoMutt,
    .mod_data = mod_data,
    .wdata = win->wdata,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; EnterFunctions[i].op != OP_NULL; i++)
  {
    const struct EnterFunction *fn = &EnterFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

env_function_dispatcher()

int env_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform an Envelope function - Implements function_dispatcher_t -.

Definition at line 536 of file functions.c.

{
  if (!event || !win || !win->wdata)
    return FR_UNKNOWN;
 
  const int op = event->op;
  int rc = FR_UNKNOWN;
  for (size_t i = 0; EnvelopeFunctions[i].op != OP_NULL; i++)
  {
    const struct EnvelopeFunction *fn = &EnvelopeFunctions[i];
    if (fn->op == op)
    {
      struct EnvelopeWindowData *wdata = win->wdata;
      rc = fn->function(wdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

global_function_dispatcher()

int global_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Global function - Implements function_dispatcher_t -.

Note

win Should be the currently focused Window

Definition at line 193 of file global.c.

{
  if (!event || !win)
    return FR_UNKNOWN;
 
  const int op = event->op;
  int rc = FR_UNKNOWN;
  for (size_t i = 0; GlobalFunctions[i].op != OP_NULL; i++)
  {
    const struct GlobalFunction *fn = &GlobalFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(win, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return FR_SUCCESS; // Whatever the outcome, we handled it
}

Here is the call graph for this function:

Here is the caller graph for this function:

history_function_dispatcher()

int history_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a History function - Implements function_dispatcher_t -.

Definition at line 85 of file functions.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
  struct Menu *menu = dlg->wdata;
  struct HistoryData *hd = menu->mdata;
  if (!hd)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; HistoryFunctions[i].op != OP_NULL; i++)
  {
    const struct HistoryFunction *fn = &HistoryFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(hd, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_function_dispatcher()

int index_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform an Index function - Implements function_dispatcher_t -.

Definition at line 4036 of file functions.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata || !win->parent || !win->parent->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
  struct IndexPrivateData *priv = win->parent->wdata;
  struct IndexSharedData *shared = dlg->wdata;
 
  struct IndexModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_INDEX);
 
  struct IndexFunctionData fdata = {
    .n = NeoMutt,
    .mod_data = mod_data,
    .shared = shared,
    .priv = priv,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; IndexFunctions[i].op != OP_NULL; i++)
  {
    const struct IndexFunction *fn = &IndexFunctions[i];
    if (fn->op == op)
    {
      if (!prereq(shared, priv->menu, fn->flags))
      {
        rc = FR_ERROR;
        break;
      }
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_function_dispatcher()

int menu_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Menu function - Implements function_dispatcher_t -.

Definition at line 366 of file functions.c.

{
  if (!event || !win || !win->wdata)
    return FR_UNKNOWN;
 
  const int op = event->op;
  struct Menu *menu = win->wdata;
 
  struct MenuFunctionData fdata = {
    .n = NeoMutt,
    .menu = menu,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; MenuFunctions[i].op != OP_NULL; i++)
  {
    const struct MenuFunction *fn = &MenuFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_tagging_dispatcher()

int menu_tagging_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform tagging operations on the Menu - Implements function_dispatcher_t -.

Definition at line 239 of file tagging.c.

{
  if (!win || !win->wdata || !event)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  struct Menu *menu = win->wdata;
  const int op = event->op;
  int rc = FR_UNKNOWN;
 
  switch (op)
  {
    case OP_END_COND:
      rc = op_end_cond(menu, op);
      break;
    case OP_TAG:
      rc = op_tag(menu, op, event->count);
      break;
    case OP_TAG_PREFIX:
      rc = op_tag_prefix(menu, op);
      break;
    case OP_TAG_PREFIX_COND:
      rc = op_tag_prefix_cond(menu, op);
      break;
    case OP_ABORT:
      rc = menu_abort(menu);
      break;
    case OP_TIMEOUT:
      rc = menu_timeout(menu);
      break;
    default:
      rc = menu_other(menu);
      break;
  }
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlist_function_dispatcher()

int mlist_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a List dialog function - Implements function_dispatcher_t -.

Definition at line 269 of file functions.c.

{
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  struct Menu *menu = dlg->wdata;
  struct ListData *ld = menu->mdata;
  if (!ld)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; MlistFunctions[i].op != OP_NULL; i++)
  {
    if (MlistFunctions[i].op == event->op)
    {
      rc = MlistFunctions[i].function(ld, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN)
    return rc;
 
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(event->op),
             event->op, NONULL(dispatcher_get_retval_name(rc)));
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gpgme_function_dispatcher()

int gpgme_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Gpgme function - Implements function_dispatcher_t -.

Definition at line 865 of file functions_gpgme.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
  struct Menu *menu = dlg->wdata;
  struct GpgmeData *gd = menu->mdata;
  if (!gd)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; GpgmeFunctions[i].op != OP_NULL; i++)
  {
    const struct GpgmeFunction *fn = &GpgmeFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(gd, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_function_dispatcher()

int pgp_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Pgp function - Implements function_dispatcher_t -.

Definition at line 227 of file functions_pgp.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
  struct Menu *menu = dlg->wdata;
  struct PgpData *pd = menu->mdata;
  if (!pd)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; PgpFunctions[i].op != OP_NULL; i++)
  {
    const struct PgpFunction *fn = &PgpFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(pd, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smime_function_dispatcher()

int smime_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Smime function - Implements function_dispatcher_t -.

Definition at line 112 of file functions_smime.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
  struct Menu *menu = dlg->wdata;
  struct SmimeData *sd = menu->mdata;
  if (!sd)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; SmimeFunctions[i].op != OP_NULL; i++)
  {
    const struct SmimeFunction *fn = &SmimeFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(sd, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pager_function_dispatcher()

int pager_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Pager function - Implements function_dispatcher_t -.

Definition at line 1055 of file functions.c.

{
  if (!win || !event)
  {
    mutt_error("%s", _(Not_available_in_this_menu));
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  if (!win->parent || !win->parent->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  struct PagerPrivateData *priv = win->parent->wdata;
 
  struct MuttWindow *dlg = dialog_find(win);
  if (!dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
 
  struct PagerModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_PAGER);
 
  struct PagerFunctionData fdata = {
    .n = NeoMutt,
    .mod_data = mod_data,
    .shared = dlg->wdata,
    .priv = priv,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; PagerFunctions[i].op != OP_NULL; i++)
  {
    const struct PagerFunction *fn = &PagerFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pattern_function_dispatcher()

int pattern_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Pattern function - Implements function_dispatcher_t -.

Definition at line 90 of file functions.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
  struct Menu *menu = dlg->wdata;
  struct PatternData *pd = menu->mdata;
  if (!pd)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  struct PatternFunctionData fdata = {
    .n = NeoMutt,
    .pd = pd,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; PatternFunctions[i].op != OP_NULL; i++)
  {
    const struct PatternFunction *fn = &PatternFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

postpone_function_dispatcher()

int postpone_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Postpone function - Implements function_dispatcher_t -.

Definition at line 285 of file functions.c.

{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
  struct Menu *menu = dlg->wdata;
  struct PostponeData *pd = menu->mdata;
  if (!pd)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; PostponeFunctions[i].op != OP_NULL; i++)
  {
    const struct PostponeFunction *fn = &PostponeFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(pd, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_fuzzy_function_dispatcher()

int sb_fuzzy_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Fuzzy Search function - Implements function_dispatcher_t -.

Definition at line 81 of file functions_fuzzy.c.

{
  if (!event || !win || !win->wdata)
    return FR_UNKNOWN;
 
  const int op = event->op;
 
  struct SidebarModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_SIDEBAR);
 
  struct SidebarFunctionData fdata = {
    .n = NeoMutt,
    .mod_data = mod_data,
    .wdata = win->wdata,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; FuzzyFunctions[i].op != OP_NULL; i++)
  {
    const struct SidebarFunction *fn = &FuzzyFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_function_dispatcher()

int sb_function_dispatcher	(	struct MuttWindow *	win,
		const struct KeyEvent *	event )

Perform a Sidebar function - Implements function_dispatcher_t -.

Definition at line 908 of file functions_sidebar.c.

{
  if (!event || !win || !win->wdata)
    return FR_UNKNOWN;
 
  const int op = event->op;
 
  struct SidebarModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_SIDEBAR);
 
  struct SidebarFunctionData fdata = {
    .n = NeoMutt,
    .mod_data = mod_data,
    .wdata = win->wdata,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; SidebarFunctions[i].op != OP_NULL; i++)
  {
    const struct SidebarFunction *fn = &SidebarFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function: