mutt_menu.h File Reference

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "keymap.h"

Include dependency graph for mutt_menu.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Menu
	GUI selectable list of items. More...

Macros
#define	REDRAW_NO_FLAGS   0
	No flags are set. More...
#define	REDRAW_INDEX   (1 << 0)
	Redraw the index. More...
#define	REDRAW_MOTION   (1 << 1)
	Redraw after moving the menu list. More...
#define	REDRAW_MOTION_RESYNC   (1 << 2)
	Redraw any changing the menu selection. More...
#define	REDRAW_CURRENT   (1 << 3)
	Redraw the current line of the menu. More...
#define	REDRAW_STATUS   (1 << 4)
	Redraw the status bar. More...
#define	REDRAW_FULL   (1 << 5)
	Redraw everything. More...
#define	REDRAW_BODY   (1 << 6)
	Redraw the pager. More...
#define	REDRAW_FLOW   (1 << 7)
	Used by pager to reflow text. More...

Typedefs
typedef uint16_t	MuttRedrawFlags
	Flags, e.g. REDRAW_INDEX. More...

Functions
void	menu_bottom_page (struct Menu *menu)
	Move the focus to the bottom of the page. More...
void	menu_check_recenter (struct Menu *menu)
	Recentre the menu on screen. More...
void	menu_current_bottom (struct Menu *menu)
	Move the current selection to the bottom of the window. More...
void	menu_current_middle (struct Menu *menu)
	Move the current selection to the centre of the window. More...
void	menu_current_top (struct Menu *menu)
	Move the current selection to the top of the window. More...
void	menu_first_entry (struct Menu *menu)
	Move the focus to the first entry in the menu. More...
void	menu_half_down (struct Menu *menu)
	Move the focus down half a page in the menu. More...
void	menu_half_up (struct Menu *menu)
	Move the focus up half a page in the menu. More...
void	menu_last_entry (struct Menu *menu)
	Move the focus to the last entry in the menu. More...
void	menu_middle_page (struct Menu *menu)
	Move the focus to the centre of the page. More...
void	menu_next_line (struct Menu *menu)
	Move the view down one line, keeping the selection the same. More...
void	menu_next_page (struct Menu *menu)
	Move the focus to the next page in the menu. More...
void	menu_prev_line (struct Menu *menu)
	Move the view up one line, keeping the selection the same. More...
void	menu_prev_page (struct Menu *menu)
	Move the focus to the previous page in the menu. More...
void	menu_redraw_current (struct Menu *menu)
	Redraw the current menu. More...
void	menu_redraw_full (struct Menu *menu)
	Force the redraw of the Menu. More...
void	menu_redraw_index (struct Menu *menu)
	Force the redraw of the index. More...
void	menu_redraw_motion (struct Menu *menu)
	Force the redraw of the list part of the menu. More...
void	menu_redraw_status (struct Menu *menu)
	Force the redraw of the status bar. More...
int	menu_redraw (struct Menu *menu)
	Redraw the parts of the screen that have been flagged to be redrawn. More...
void	menu_top_page (struct Menu *menu)
	Move the focus to the top of the page. More...
void	mutt_menu_add_dialog_row (struct Menu *menu, const char *row)
	Add a row to a Menu. More...
void	mutt_menu_current_redraw (void)
	Redraw the current menu. More...
void	mutt_menu_free (struct Menu **ptr)
	Destroy a menu. More...
void	mutt_menu_init (void)
	Initialise all the Menus. More...
int	mutt_menu_loop (struct Menu *menu)
	Menu event loop. More...
struct Menu *	mutt_menu_new (enum MenuType type)
	Create a new Menu. More...
void	mutt_menu_pop_current (struct Menu *menu)
	Remove a Menu from the stack. More...
void	mutt_menu_push_current (struct Menu *menu)
	Add a new Menu to the stack. More...
void	mutt_menu_set_current_redraw_full (void)
	Flag the current menu to be fully redrawn. More...
void	mutt_menu_set_current_redraw (MuttRedrawFlags redraw)
	Set redraw flags on the current menu. More...
void	mutt_menu_set_redraw_full (enum MenuType menu)
	Flag a menu to be fully redrawn. More...
void	mutt_menu_set_redraw (enum MenuType menu, MuttRedrawFlags redraw)
	Set redraw flags on a menu. More...
int	mutt_menu_color_observer (struct NotifyCallback *nc)
	Listen for colour changes affecting the menu - Implements observer_t. More...
int	mutt_menu_config_observer (struct NotifyCallback *nc)
	Listen for config changes affecting the menu - Implements observer_t. More...

Variables
short	C_MenuContext
	Config: Number of lines of overlap when changing pages in the index. More...
bool	C_MenuMoveOff
	Config: Allow the last menu item to move off the bottom of the screen. More...
bool	C_MenuScroll
	Config: Scroll the menu/index by one line, rather than a page. More...

Detailed Description

GUI present the user with a selectable list

Authors

• Richard Russon

Copyright

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

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

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

Definition in file mutt_menu.h.

Macro Definition Documentation

REDRAW_NO_FLAGS

#define REDRAW_NO_FLAGS   0

No flags are set.

Definition at line 39 of file mutt_menu.h.

REDRAW_INDEX

#define REDRAW_INDEX   (1 << 0)

Redraw the index.

Definition at line 40 of file mutt_menu.h.

REDRAW_MOTION

#define REDRAW_MOTION   (1 << 1)

Redraw after moving the menu list.

Definition at line 41 of file mutt_menu.h.

REDRAW_MOTION_RESYNC

#define REDRAW_MOTION_RESYNC   (1 << 2)

Redraw any changing the menu selection.

Definition at line 42 of file mutt_menu.h.

REDRAW_CURRENT

#define REDRAW_CURRENT   (1 << 3)

Redraw the current line of the menu.

Definition at line 43 of file mutt_menu.h.

REDRAW_STATUS

#define REDRAW_STATUS   (1 << 4)

Redraw the status bar.

Definition at line 44 of file mutt_menu.h.

REDRAW_FULL

#define REDRAW_FULL   (1 << 5)

Redraw everything.

Definition at line 45 of file mutt_menu.h.

REDRAW_BODY

#define REDRAW_BODY   (1 << 6)

Redraw the pager.

Definition at line 46 of file mutt_menu.h.

REDRAW_FLOW

#define REDRAW_FLOW   (1 << 7)

Used by pager to reflow text.

Definition at line 47 of file mutt_menu.h.

Typedef Documentation

MuttRedrawFlags

typedef uint16_t MuttRedrawFlags

Flags, e.g. REDRAW_INDEX.

Definition at line 38 of file mutt_menu.h.

Function Documentation

menu_bottom_page()

void menu_bottom_page

(

struct Menu *

menu

)

Move the focus to the bottom of the page.

Parameters

menu	Current Menu

Definition at line 776 of file menu.c.

{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return;
  }
 
  menu->current = menu->top + menu->pagelen - 1;
  if (menu->current > (menu->max - 1))
    menu->current = menu->max - 1;
  menu->redraw = REDRAW_MOTION;
}

Here is the caller graph for this function:

menu_check_recenter()

void menu_check_recenter

(

struct Menu *

menu

)

Recentre the menu on screen.

Parameters

menu	Current Menu

Definition at line 544 of file menu.c.

{
  int c = MIN(C_MenuContext, (menu->pagelen / 2));
  int old_top = menu->top;
 
  if (!C_MenuMoveOff && (menu->max <= menu->pagelen)) /* less entries than lines */
  {
    if (menu->top != 0)
    {
      menu->top = 0;
      menu->redraw |= REDRAW_INDEX;
    }
  }
  else
  {
    if (C_MenuScroll || (menu->pagelen <= 0) || (c < C_MenuContext))
    {
      if (menu->current < (menu->top + c))
        menu->top = menu->current - c;
      else if (menu->current >= (menu->top + menu->pagelen - c))
        menu->top = menu->current - menu->pagelen + c + 1;
    }
    else
    {
      if (menu->current < menu->top + c)
      {
        menu->top -= (menu->pagelen - c) * ((menu->top + menu->pagelen - 1 - menu->current) /
                                            (menu->pagelen - c)) -
                     c;
      }
      else if ((menu->current >= (menu->top + menu->pagelen - c)))
      {
        menu->top +=
            (menu->pagelen - c) * ((menu->current - menu->top) / (menu->pagelen - c)) - c;
      }
    }
  }
 
  if (!C_MenuMoveOff) /* make entries stick to bottom */
    menu->top = MIN(menu->top, menu->max - menu->pagelen);
  menu->top = MAX(menu->top, 0);
 
  if (menu->top != old_top)
    menu->redraw |= REDRAW_INDEX;
}

Here is the caller graph for this function:

menu_current_bottom()

void menu_current_bottom

(

struct Menu *

menu

)

Move the current selection to the bottom of the window.

Parameters

menu	Current Menu

Definition at line 879 of file menu.c.

{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return;
  }
 
  menu->top = menu->current - menu->pagelen + 1;
  if (menu->top < 0)
    menu->top = 0;
  menu->redraw = REDRAW_INDEX;
}

Here is the caller graph for this function:

menu_current_middle()

void menu_current_middle

(

struct Menu *

menu

)

Move the current selection to the centre of the window.

Parameters

menu	Current Menu

Definition at line 861 of file menu.c.

{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return;
  }
 
  menu->top = menu->current - (menu->pagelen / 2);
  if (menu->top < 0)
    menu->top = 0;
  menu->redraw = REDRAW_INDEX;
}

Here is the caller graph for this function:

menu_current_top()

void menu_current_top

(

struct Menu *

menu

)

Move the current selection to the top of the window.

Parameters

menu	Current Menu

Definition at line 845 of file menu.c.

{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return;
  }
 
  menu->top = menu->current;
  menu->redraw = REDRAW_INDEX;
}

Here is the caller graph for this function:

menu_first_entry()

void menu_first_entry

(

struct Menu *

menu

)

Move the focus to the first entry in the menu.

Parameters

menu	Current Menu

Definition at line 813 of file menu.c.

{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return;
  }
 
  menu->current = 0;
  menu->redraw = REDRAW_MOTION;
}

Here is the caller graph for this function:

menu_half_down()

void menu_half_down

(

struct Menu *

menu

)

Move the focus down half a page in the menu.

Parameters

menu	Current Menu

Definition at line 745 of file menu.c.

{
  menu_length_jump(menu, (menu->pagelen / 2));
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_half_up()

void menu_half_up

(

struct Menu *

menu

)

Move the focus up half a page in the menu.

Parameters

menu	Current Menu

Definition at line 754 of file menu.c.

{
  menu_length_jump(menu, 0 - (menu->pagelen / 2));
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_last_entry()

void menu_last_entry

(

struct Menu *

menu

)

Move the focus to the last entry in the menu.

Parameters

menu	Current Menu

Definition at line 829 of file menu.c.

{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return;
  }
 
  menu->current = menu->max - 1;
  menu->redraw = REDRAW_MOTION;
}

Here is the caller graph for this function:

menu_middle_page()

void menu_middle_page

(

struct Menu *

menu

)

Move the focus to the centre of the page.

Parameters

menu	Current Menu

Definition at line 794 of file menu.c.

{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return;
  }
 
  int i = menu->top + menu->pagelen;
  if (i > (menu->max - 1))
    i = menu->max - 1;
  menu->current = menu->top + (i - menu->top) / 2;
  menu->redraw = REDRAW_MOTION;
}

Here is the caller graph for this function:

menu_next_line()

void menu_next_line

(

struct Menu *

menu

)

Move the view down one line, keeping the selection the same.

Parameters

menu	Current Menu

Definition at line 625 of file menu.c.

{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return;
  }
 
  int c = MIN(C_MenuContext, (menu->pagelen / 2));
 
  if (((menu->top + 1) < (menu->max - c)) &&
      (C_MenuMoveOff ||
       ((menu->max > menu->pagelen) && (menu->top < (menu->max - menu->pagelen)))))
  {
    menu->top++;
    if ((menu->current < (menu->top + c)) && (menu->current < (menu->max - 1)))
      menu->current++;
    menu->redraw = REDRAW_INDEX;
  }
  else
    mutt_message(_("You can't scroll down farther"));
}

Here is the caller graph for this function:

menu_next_page()

void menu_next_page

(

struct Menu *

menu

)

Move the focus to the next page in the menu.

Parameters

menu	Current Menu

Definition at line 727 of file menu.c.

{
  menu_length_jump(menu, MAX(menu->pagelen /* - MenuOverlap */, 0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_prev_line()

void menu_prev_line

(

struct Menu *

menu

)

Move the view up one line, keeping the selection the same.

Parameters

menu	Current Menu

Definition at line 652 of file menu.c.

{
  if (menu->top < 1)
  {
    mutt_message(_("You can't scroll up farther"));
    return;
  }
 
  int c = MIN(C_MenuContext, (menu->pagelen / 2));
 
  menu->top--;
  if ((menu->current >= (menu->top + menu->pagelen - c)) && (menu->current > 1))
    menu->current--;
  menu->redraw = REDRAW_INDEX;
}

Here is the caller graph for this function:

menu_prev_page()

void menu_prev_page

(

struct Menu *

menu

)

Move the focus to the previous page in the menu.

Parameters

menu	Current Menu

Definition at line 736 of file menu.c.

{
  menu_length_jump(menu, 0 - MAX(menu->pagelen /* - MenuOverlap */, 0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_redraw_current()

void menu_redraw_current

(

struct Menu *

menu

)

Redraw the current menu.

Parameters

menu	Current Menu

Definition at line 494 of file menu.c.

{
  char buf[1024];
  int attr = menu->color(menu, menu->current);
 
  mutt_window_move(menu->win_index, 0, menu->current - menu->top);
  make_entry(menu, buf, sizeof(buf), menu->current);
  menu_pad_string(menu, buf, sizeof(buf));
 
  mutt_curses_set_color(MT_COLOR_INDICATOR);
  if (C_ArrowCursor)
  {
    mutt_window_addstr(C_ArrowString);
    mutt_curses_set_attr(attr);
    mutt_window_addch(' ');
    menu_pad_string(menu, buf, sizeof(buf));
    print_enriched_string(menu->current, attr, (unsigned char *) buf, true);
  }
  else
    print_enriched_string(menu->current, attr, (unsigned char *) buf, false);
  menu->redraw &= REDRAW_STATUS;
  mutt_curses_set_color(MT_COLOR_NORMAL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_redraw_full()

void menu_redraw_full

(

struct Menu *

menu

)

Force the redraw of the Menu.

Parameters

menu	Current Menu

Definition at line 348 of file menu.c.

{
  mutt_curses_set_color(MT_COLOR_NORMAL);
  mutt_window_clear(menu->win_index);
 
  window_redraw(RootWindow, true);
  menu->pagelen = menu->win_index->state.rows;
 
  mutt_show_error();
 
  menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_redraw_index()

void menu_redraw_index

(

struct Menu *

menu

)

Force the redraw of the index.

Parameters

menu	Current Menu

Definition at line 381 of file menu.c.

{
  char buf[1024];
  bool do_color;
  int attr;
 
  for (int i = menu->top; i < (menu->top + menu->pagelen); i++)
  {
    if (i < menu->max)
    {
      attr = menu->color(menu, i);
 
      make_entry(menu, buf, sizeof(buf), i);
      menu_pad_string(menu, buf, sizeof(buf));
 
      mutt_curses_set_attr(attr);
      mutt_window_move(menu->win_index, 0, i - menu->top);
      do_color = true;
 
      if (i == menu->current)
      {
        mutt_curses_set_color(MT_COLOR_INDICATOR);
        if (C_ArrowCursor)
        {
          mutt_window_addstr(C_ArrowString);
          mutt_curses_set_attr(attr);
          mutt_window_addch(' ');
        }
        else
          do_color = false;
      }
      else if (C_ArrowCursor)
      {
        /* Print space chars to match the screen width of `$arrow_string` */
        mutt_window_printf("%*s", mutt_strwidth(C_ArrowString) + 1, "");
      }
 
      print_enriched_string(i, attr, (unsigned char *) buf, do_color);
    }
    else
    {
      mutt_curses_set_color(MT_COLOR_NORMAL);
      mutt_window_clearline(menu->win_index, i - menu->top);
    }
  }
  mutt_curses_set_color(MT_COLOR_NORMAL);
  menu->redraw = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_redraw_motion()

void menu_redraw_motion

(

struct Menu *

menu

)

Force the redraw of the list part of the menu.

Parameters

menu	Current Menu

Definition at line 434 of file menu.c.

{
  char buf[1024];
 
  if (!ARRAY_EMPTY(&menu->dialog))
  {
    menu->redraw &= ~REDRAW_MOTION;
    return;
  }
 
  /* Note: menu->color() for the index can end up retrieving a message
   * over imap (if matching against ~h for instance).  This can
   * generate status messages.  So we want to call it *before* we
   * position the cursor for drawing. */
  const int old_color = menu->color(menu, menu->oldcurrent);
  mutt_window_move(menu->win_index, 0, menu->oldcurrent - menu->top);
  mutt_curses_set_attr(old_color);
 
  if (C_ArrowCursor)
  {
    /* clear the arrow */
    /* Print space chars to match the screen width of `$arrow_string` */
    mutt_window_printf("%*s", mutt_strwidth(C_ArrowString) + 1, "");
 
    if (menu->redraw & REDRAW_MOTION_RESYNC)
    {
      make_entry(menu, buf, sizeof(buf), menu->oldcurrent);
      menu_pad_string(menu, buf, sizeof(buf));
      mutt_window_move(menu->win_index, mutt_strwidth(C_ArrowString) + 1,
                       menu->oldcurrent - menu->top);
      print_enriched_string(menu->oldcurrent, old_color, (unsigned char *) buf, true);
    }
 
    /* now draw it in the new location */
    mutt_curses_set_color(MT_COLOR_INDICATOR);
    mutt_window_mvaddstr(menu->win_index, 0, menu->current - menu->top, C_ArrowString);
  }
  else
  {
    /* erase the current indicator */
    make_entry(menu, buf, sizeof(buf), menu->oldcurrent);
    menu_pad_string(menu, buf, sizeof(buf));
    print_enriched_string(menu->oldcurrent, old_color, (unsigned char *) buf, true);
 
    /* now draw the new one to reflect the change */
    const int cur_color = menu->color(menu, menu->current);
    make_entry(menu, buf, sizeof(buf), menu->current);
    menu_pad_string(menu, buf, sizeof(buf));
    mutt_curses_set_color(MT_COLOR_INDICATOR);
    mutt_window_move(menu->win_index, 0, menu->current - menu->top);
    print_enriched_string(menu->current, cur_color, (unsigned char *) buf, false);
  }
  menu->redraw &= REDRAW_STATUS;
  mutt_curses_set_color(MT_COLOR_NORMAL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_redraw_status()

void menu_redraw_status

(

struct Menu *

menu

)

Force the redraw of the status bar.

Parameters

menu	Current Menu

Definition at line 365 of file menu.c.

{
  char buf[256];
 
  snprintf(buf, sizeof(buf), "-- NeoMutt: %s", menu->title);
  mutt_curses_set_color(MT_COLOR_STATUS);
  mutt_window_move(menu->win_ibar, 0, 0);
  mutt_paddstr(menu->win_ibar->state.cols, buf);
  mutt_curses_set_color(MT_COLOR_NORMAL);
  menu->redraw &= ~REDRAW_STATUS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_redraw()

int menu_redraw

(

struct Menu *

menu

)

Redraw the parts of the screen that have been flagged to be redrawn.

Parameters

menu	Menu to redraw

Return values

OP_NULL	Menu was redrawn
OP_REDRAW	Full redraw required

Definition at line 1270 of file menu.c.

{
  if (menu->custom_redraw)
  {
    menu->custom_redraw(menu);
    return OP_NULL;
  }
 
  /* See if all or part of the screen needs to be updated.  */
  if (menu->redraw & REDRAW_FULL)
  {
    menu_redraw_full(menu);
    /* allow the caller to do any local configuration */
    return OP_REDRAW;
  }
 
  if (ARRAY_EMPTY(&menu->dialog))
    menu_check_recenter(menu);
 
  if (menu->redraw & REDRAW_STATUS)
    menu_redraw_status(menu);
  if (menu->redraw & REDRAW_INDEX)
    menu_redraw_index(menu);
  else if (menu->redraw & (REDRAW_MOTION | REDRAW_MOTION_RESYNC))
    menu_redraw_motion(menu);
  else if (menu->redraw == REDRAW_CURRENT)
    menu_redraw_current(menu);
 
  if (!ARRAY_EMPTY(&menu->dialog))
    menu_redraw_prompt(menu);
 
  return OP_NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_top_page()

void menu_top_page

(

struct Menu *

menu

)

Move the focus to the top of the page.

Parameters

menu	Current Menu

Definition at line 763 of file menu.c.

{
  if (menu->current == menu->top)
    return;
 
  menu->current = menu->top;
  menu->redraw = REDRAW_MOTION;
}

Here is the caller graph for this function:

mutt_menu_add_dialog_row()

void mutt_menu_add_dialog_row	(	struct Menu *	menu,
		const char *	row
	)

Add a row to a Menu.

Parameters

menu	Menu to add to
row	Row of text to add

Definition at line 993 of file menu.c.

{
  ARRAY_SET(&menu->dialog, menu->max, mutt_str_dup(row));
  menu->max++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_current_redraw()

void mutt_menu_current_redraw

(

void

)

Redraw the current menu.

Definition at line 1107 of file menu.c.

{
  struct Menu *current_menu = get_current_menu();
  if (current_menu)
  {
    if (menu_redraw(current_menu) == OP_REDRAW)
    {
      /* On a REDRAW_FULL with a non-customized redraw, menu_redraw()
       * will return OP_REDRAW to give the calling menu-loop a chance to
       * customize output.  */
      menu_redraw(current_menu);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_free()

void mutt_menu_free

(

struct Menu **

ptr

)

Destroy a menu.

Parameters

[out]

ptr

Menu to destroy

Definition at line 972 of file menu.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct Menu *menu = *ptr;
  char **line = NULL;
  ARRAY_FOREACH(line, &menu->dialog)
  {
    FREE(line);
  }
  ARRAY_FREE(&menu->dialog);
 
  FREE(ptr);
}

Here is the caller graph for this function:

mutt_menu_init()

void mutt_menu_init

(

void

)

Initialise all the Menus.

Definition at line 945 of file menu.c.

{
  for (int i = 0; i < MENU_MAX; i++)
    SearchBuffers[i] = NULL;
}

Here is the caller graph for this function:

mutt_menu_loop()

int mutt_menu_loop

(

struct Menu *

menu

)

Menu event loop.

Parameters

menu	Current Menu

Return values

num	An event id that the menu can't process

Definition at line 1309 of file menu.c.

{
  static int last_position = -1;
  int op = OP_NULL;
 
  if (menu->max && menu->is_mailbox_list)
  {
    if (last_position > (menu->max - 1))
      last_position = -1;
    else if (last_position >= 0)
      menu->current = last_position;
  }
 
  while (true)
  {
    /* Clear the tag prefix unless we just started it.  Don't clear
     * the prefix on a timeout (op==-2), but do clear on an abort (op==-1) */
    if (menu->tagprefix && (op != OP_TAG_PREFIX) &&
        (op != OP_TAG_PREFIX_COND) && (op != -2))
    {
      menu->tagprefix = false;
    }
 
    mutt_curses_set_cursor(MUTT_CURSOR_INVISIBLE);
 
    if (menu_redraw(menu) == OP_REDRAW)
      return OP_REDRAW;
 
    /* give visual indication that the next command is a tag- command */
    if (menu->tagprefix)
    {
      mutt_window_mvaddstr(MessageWindow, 0, 0, "tag-");
      mutt_window_clrtoeol(MessageWindow);
    }
 
    menu->oldcurrent = menu->current;
 
    /* move the cursor out of the way */
    if (C_ArrowCursor)
      mutt_window_move(menu->win_index, 2, menu->current - menu->top);
    else if (C_BrailleFriendly)
      mutt_window_move(menu->win_index, 0, menu->current - menu->top);
    else
    {
      mutt_window_move(menu->win_index, menu->win_index->state.cols - 1,
                       menu->current - menu->top);
    }
 
    mutt_refresh();
 
    /* try to catch dialog keys before ops */
    if (!ARRAY_EMPTY(&menu->dialog) && (menu_dialog_dokey(menu, &op) == 0))
      return op;
 
    op = km_dokey(menu->type);
    if ((op == OP_TAG_PREFIX) || (op == OP_TAG_PREFIX_COND))
    {
      if (menu->tagprefix)
      {
        menu->tagprefix = false;
        mutt_window_clearline(MessageWindow, 0);
        continue;
      }
 
      if (menu->tagged)
      {
        menu->tagprefix = true;
        continue;
      }
      else if (op == OP_TAG_PREFIX)
      {
        mutt_error(_("No tagged entries"));
        op = -1;
      }
      else /* None tagged, OP_TAG_PREFIX_COND */
      {
        mutt_flush_macro_to_endcond();
        mutt_message(_("Nothing to do"));
        op = -1;
      }
    }
    else if (menu->tagged && C_AutoTag)
      menu->tagprefix = true;
 
    mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
 
    if (SigWinch)
    {
      SigWinch = 0;
      mutt_resize_screen();
      clearok(stdscr, true); /* force complete redraw */
    }
 
    if (op < 0)
    {
      if (menu->tagprefix)
        mutt_window_clearline(MessageWindow, 0);
      continue;
    }
 
    if (ARRAY_EMPTY(&menu->dialog))
      mutt_clear_error();
 
    /* Convert menubar movement to scrolling */
    if (!ARRAY_EMPTY(&menu->dialog))
      op = menu_dialog_translate_op(op);
 
    switch (op)
    {
      case OP_NEXT_ENTRY:
        menu_next_entry(menu);
        break;
      case OP_PREV_ENTRY:
        menu_prev_entry(menu);
        break;
      case OP_HALF_DOWN:
        menu_half_down(menu);
        break;
      case OP_HALF_UP:
        menu_half_up(menu);
        break;
      case OP_NEXT_PAGE:
        menu_next_page(menu);
        break;
      case OP_PREV_PAGE:
        menu_prev_page(menu);
        break;
      case OP_NEXT_LINE:
        menu_next_line(menu);
        break;
      case OP_PREV_LINE:
        menu_prev_line(menu);
        break;
      case OP_FIRST_ENTRY:
        menu_first_entry(menu);
        break;
      case OP_LAST_ENTRY:
        menu_last_entry(menu);
        break;
      case OP_TOP_PAGE:
        menu_top_page(menu);
        break;
      case OP_MIDDLE_PAGE:
        menu_middle_page(menu);
        break;
      case OP_BOTTOM_PAGE:
        menu_bottom_page(menu);
        break;
      case OP_CURRENT_TOP:
        menu_current_top(menu);
        break;
      case OP_CURRENT_MIDDLE:
        menu_current_middle(menu);
        break;
      case OP_CURRENT_BOTTOM:
        menu_current_bottom(menu);
        break;
      case OP_SEARCH:
      case OP_SEARCH_REVERSE:
      case OP_SEARCH_NEXT:
      case OP_SEARCH_OPPOSITE:
        if (menu->custom_search)
          return op;
        else if (menu->search && ARRAY_EMPTY(&menu->dialog)) /* Searching dialogs won't work */
        {
          menu->oldcurrent = menu->current;
          menu->current = search(menu, op);
          if (menu->current != -1)
            menu->redraw = REDRAW_MOTION;
          else
            menu->current = menu->oldcurrent;
        }
        else
          mutt_error(_("Search is not implemented for this menu"));
        break;
 
      case OP_JUMP:
        if (!ARRAY_EMPTY(&menu->dialog))
          mutt_error(_("Jumping is not implemented for dialogs"));
        else
          menu_jump(menu);
        break;
 
      case OP_ENTER_COMMAND:
        mutt_enter_command();
        window_set_focus(menu->win_index);
        window_redraw(RootWindow, false);
        break;
 
      case OP_TAG:
        if (menu->tag && ARRAY_EMPTY(&menu->dialog))
        {
          if (menu->tagprefix && !C_AutoTag)
          {
            for (int i = 0; i < menu->max; i++)
              menu->tagged += menu->tag(menu, i, 0);
            menu->redraw |= REDRAW_INDEX;
          }
          else if (menu->max != 0)
          {
            int j = menu->tag(menu, menu->current, -1);
            menu->tagged += j;
            if (j && C_Resolve && (menu->current < (menu->max - 1)))
            {
              menu->current++;
              menu->redraw |= REDRAW_MOTION_RESYNC;
            }
            else
              menu->redraw |= REDRAW_CURRENT;
          }
          else
            mutt_error(_("No entries"));
        }
        else
          mutt_error(_("Tagging is not supported"));
        break;
 
      case OP_SHELL_ESCAPE:
        if (mutt_shell_escape())
        {
          mutt_mailbox_check(ctx_mailbox(Context), MUTT_MAILBOX_CHECK_FORCE);
        }
        break;
 
      case OP_WHAT_KEY:
        mutt_what_key();
        break;
 
      case OP_CHECK_STATS:
        mutt_check_stats(ctx_mailbox(Context));
        break;
 
      case OP_REDRAW:
        clearok(stdscr, true);
        menu->redraw = REDRAW_FULL;
        break;
 
      case OP_HELP:
        mutt_help(menu->type);
        menu->redraw = REDRAW_FULL;
        break;
 
      case OP_NULL:
        km_error_key(menu->type);
        break;
 
      case OP_END_COND:
        break;
 
      default:
        if (menu->is_mailbox_list)
          last_position = menu->current;
        return op;
    }
  }
  /* not reached */
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_new()

struct Menu* mutt_menu_new

(

enum MenuType

type

)

Create a new Menu.

Parameters

type	Menu type, e.g. MENU_PAGER

Return values

ptr

New Menu

Definition at line 956 of file menu.c.

{
  struct Menu *menu = mutt_mem_calloc(1, sizeof(struct Menu));
 
  menu->type = type;
  menu->redraw = REDRAW_FULL;
  menu->color = default_color;
  menu->search = generic_search;
 
  return menu;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_pop_current()

void mutt_menu_pop_current

(

struct Menu *

menu

)

Remove a Menu from the stack.

Parameters

menu	Current Menu

The menus are stored in a LIFO. The top-most is shown to the user.

Definition at line 1027 of file menu.c.

{
  struct Menu *prev_menu = NULL;
 
  if (ARRAY_EMPTY(&MenuStack) || (*ARRAY_LAST(&MenuStack) != menu))
  {
    mutt_debug(LL_DEBUG1, "called with inactive menu\n");
    return;
  }
  ARRAY_SHRINK(&MenuStack, 1);
 
  prev_menu = get_current_menu();
  if (prev_menu)
  {
    CurrentMenu = prev_menu->type;
    prev_menu->redraw = REDRAW_FULL;
  }
  else
  {
    CurrentMenu = MENU_MAIN;
    /* Clearing when NeoMutt exits would be an annoying change in behavior for
     * those who have disabled alternative screens.  The option is currently
     * set by autocrypt initialization which mixes menus and prompts outside of
     * the normal menu system state.  */
    if (OptMenuPopClearScreen)
    {
      mutt_window_clear(RootWindow);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_push_current()

void mutt_menu_push_current

(

struct Menu *

menu

)

Add a new Menu to the stack.

Parameters

menu	Menu to add

The menus are stored in a LIFO. The top-most is shown to the user.

Definition at line 1015 of file menu.c.

{
  ARRAY_ADD(&MenuStack, menu);
  CurrentMenu = menu->type;
}

Here is the caller graph for this function:

mutt_menu_set_current_redraw_full()

void mutt_menu_set_current_redraw_full

(

void

)

Flag the current menu to be fully redrawn.

Definition at line 1072 of file menu.c.

{
  struct Menu *current_menu = get_current_menu();
  if (current_menu)
    current_menu->redraw = REDRAW_FULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_set_current_redraw()

void mutt_menu_set_current_redraw

(

MuttRedrawFlags

redraw

)

Set redraw flags on the current menu.

Parameters

redraw

Flags to set, see MuttRedrawFlags

Definition at line 1062 of file menu.c.

{
  struct Menu *current_menu = get_current_menu();
  if (current_menu)
    current_menu->redraw |= redraw;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_set_redraw_full()

void mutt_menu_set_redraw_full

(

enum MenuType

menu

)

Flag a menu to be fully redrawn.

Parameters

menu	Menu type, e.g. MENU_ALIAS

This is ignored if it's not the current menu.

Definition at line 1098 of file menu.c.

{
  if (CurrentMenu == menu)
    mutt_menu_set_current_redraw_full();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_set_redraw()

void mutt_menu_set_redraw	(	enum MenuType	menu,
		MuttRedrawFlags	redraw
	)

Set redraw flags on a menu.

Parameters

menu	Menu type, e.g. MENU_ALIAS
redraw	Flags, e.g. REDRAW_INDEX

This is ignored if it's not the current menu.

Definition at line 1086 of file menu.c.

{
  if (CurrentMenu == menu)
    mutt_menu_set_current_redraw(redraw);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_color_observer()

int mutt_menu_color_observer

(

struct NotifyCallback *

nc

)

Listen for colour changes affecting the menu - Implements observer_t.

Definition at line 1570 of file menu.c.

{
  if (!nc->event_data)
    return -1;
  if (nc->event_type != NT_CONFIG)
    return 0;
 
  struct EventColor *ev_c = nc->event_data;
 
  int c = ev_c->color;
 
  bool simple = (c == MT_COLOR_INDEX_COLLAPSED) || (c == MT_COLOR_INDEX_DATE) ||
                (c == MT_COLOR_INDEX_LABEL) || (c == MT_COLOR_INDEX_NUMBER) ||
                (c == MT_COLOR_INDEX_SIZE) || (c == MT_COLOR_INDEX_TAGS);
  bool lists = (c == MT_COLOR_ATTACH_HEADERS) || (c == MT_COLOR_BODY) ||
               (c == MT_COLOR_HEADER) || (c == MT_COLOR_INDEX) ||
               (c == MT_COLOR_INDEX_AUTHOR) || (c == MT_COLOR_INDEX_FLAGS) ||
               (c == MT_COLOR_INDEX_SUBJECT) || (c == MT_COLOR_INDEX_TAG);
 
  // The changes aren't relevant to the index menu
  if (!simple && !lists)
    return 0;
 
  // Colour deleted from a list
  struct Mailbox *m = ctx_mailbox(Context);
  if ((nc->event_subtype == NT_COLOR_RESET) && lists && m)
  {
    // Force re-caching of index colors
    for (int i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      e->pair = 0;
    }
  }
 
  mutt_menu_set_redraw_full(MENU_MAIN);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_menu_config_observer()

int mutt_menu_config_observer

(

struct NotifyCallback *

nc

)

Listen for config changes affecting the menu - Implements observer_t.

Definition at line 1614 of file menu.c.

{
  if (!nc->event_data)
    return -1;
  if (nc->event_type != NT_CONFIG)
    return 0;
 
  struct EventConfig *ec = nc->event_data;
 
  const struct ConfigDef *cdef = ec->he->data;
  ConfigRedrawFlags flags = cdef->type & R_REDRAW_MASK;
 
  if (flags == R_REDRAW_NO_FLAGS)
    return 0;
 
  if (flags & R_INDEX)
    mutt_menu_set_redraw_full(MENU_MAIN);
  if (flags & R_PAGER)
    mutt_menu_set_redraw_full(MENU_PAGER);
  if (flags & R_PAGER_FLOW)
  {
    mutt_menu_set_redraw_full(MENU_PAGER);
    mutt_menu_set_redraw(MENU_PAGER, REDRAW_FLOW);
  }
 
  if (flags & R_RESORT_SUB)
    OptSortSubthreads = true;
  if (flags & R_RESORT)
    OptNeedResort = true;
  if (flags & R_RESORT_INIT)
    OptResortInit = true;
  if (flags & R_TREE)
    OptRedrawTree = true;
 
  if (flags & R_REFLOW)
    mutt_window_reflow(NULL);
  if (flags & R_MENU)
    mutt_menu_set_current_redraw_full();
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

C_MenuContext

short C_MenuContext

Config: Number of lines of overlap when changing pages in the index.

Definition at line 56 of file menu.c.

C_MenuMoveOff

bool C_MenuMoveOff

Config: Allow the last menu item to move off the bottom of the screen.

Definition at line 57 of file menu.c.

C_MenuScroll

bool C_MenuScroll

Config: Scroll the menu/index by one line, rather than a page.

Definition at line 58 of file menu.c.