menu.c File Reference

GUI present the user with a selectable list. More...

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "private.h"
#include "mutt/lib.h"
#include "config/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "menu/lib.h"
#include "commands.h"
#include "context.h"
#include "keymap.h"
#include "mutt_globals.h"
#include "mutt_logging.h"
#include "mutt_mailbox.h"
#include "opcodes.h"
#include "protos.h"
#include "type.h"

Include dependency graph for menu.c:

Go to the source code of this file.

Macros
#define	MUTT_SEARCH_UP   1
#define	MUTT_SEARCH_DOWN   2

Functions
static void	menu_jump (struct Menu *menu)
	Jump to another item in the menu. More...
static int	default_color (struct Menu *menu, int line)
	Get the default colour for a line of the menu - Implements Menu::color() -. More...
static int	generic_search (struct Menu *menu, regex_t *rx, int line)
	Search a menu for a item matching a regex - Implements Menu::search() -. More...
void	menu_cleanup (void)
	Free the saved Menu searches. More...
void	menu_init (void)
	Initialise all the Menus. More...
void	menu_add_dialog_row (struct Menu *menu, const char *row)
	Add a row to a Menu. More...
static int	search (struct Menu *menu, int op)
	Search a menu. More...
static int	menu_dialog_translate_op (int i)
	Convert menubar movement to scrolling. More...
static int	menu_dialog_dokey (struct Menu *menu, int *ip)
	Check if there are any menu key events to process. More...
int	menu_loop (struct Menu *menu)
	Menu event loop. More...
enum MenuType	menu_get_current_type (void)
	Get the type of the current Window. More...
void	menu_free (struct Menu **ptr)
	Free a Menu. More...
struct Menu *	menu_new (enum MenuType type, struct MuttWindow *win, struct ConfigSubset *sub)
	Create a new Menu. More...
int	menu_get_index (struct Menu *menu)
	Get the current selection in the Menu. More...
MenuRedrawFlags	menu_set_index (struct Menu *menu, int index)
	Set the current selection in the Menu. More...
void	menu_queue_redraw (struct Menu *menu, MenuRedrawFlags redraw)
	Queue a request for a redraw. More...

Variables
char *	SearchBuffers [MENU_MAX]

Detailed Description

GUI present the user with a selectable list.

Authors

• Michael R. Elkins
• R Primus

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 menu.c.

Macro Definition Documentation

MUTT_SEARCH_UP

#define MUTT_SEARCH_UP   1

Definition at line 53 of file menu.c.

MUTT_SEARCH_DOWN

#define MUTT_SEARCH_DOWN   2

Definition at line 54 of file menu.c.

Function Documentation

menu_jump()

static void menu_jump ( struct Menu *  menu )

static

Jump to another item in the menu.

Parameters

menu	Current Menu

Ask the user for a message number to jump to.

Definition at line 62 of file menu.c.

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

  mutt_unget_event(LastKey, 0);
  char buf[128] = { 0 };
  if ((mutt_get_field(_("Jump to: "), buf, sizeof(buf), MUTT_COMP_NO_FLAGS,
                      false, NULL, NULL) == 0) &&
      (buf[0] != '\0'))
  {
    int n = 0;
    if ((mutt_str_atoi(buf, &n) == 0) && (n > 0) && (n < (menu->max + 1)))
    {
      menu_set_index(menu, n - 1); // msg numbers are 0-based
    }
    else
      mutt_error(_("Invalid index number"));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_cleanup()

void menu_cleanup

(

void

)

Free the saved Menu searches.

Definition at line 108 of file menu.c.

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

Here is the caller graph for this function:

menu_init()

void menu_init

(

void

)

Initialise all the Menus.

Definition at line 117 of file menu.c.

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

Here is the caller graph for this function:

menu_add_dialog_row()

void 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 128 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:

search()

static int search ( struct Menu *  menu, int  op  )

static

Search a menu.

Parameters

menu	Menu to search
op	Search operation, e.g. OP_SEARCH_NEXT

Return values

>=0	Index of matching item
-1	Search failed, or was cancelled

Definition at line 141 of file menu.c.

{
  int rc = 0, wrap = 0;
  int search_dir;
  regex_t re;
  char buf[128];
  char *search_buf = ((menu->type < MENU_MAX)) ? SearchBuffers[menu->type] : NULL;

  if (!(search_buf && *search_buf) || ((op != OP_SEARCH_NEXT) && (op != OP_SEARCH_OPPOSITE)))
  {
    mutt_str_copy(buf, search_buf && (search_buf[0] != '\0') ? search_buf : "",
                  sizeof(buf));
    if ((mutt_get_field(((op == OP_SEARCH) || (op == OP_SEARCH_NEXT)) ?
                            _("Search for: ") :
                            _("Reverse search for: "),
                        buf, sizeof(buf), MUTT_CLEAR, false, NULL, NULL) != 0) ||
        (buf[0] == '\0'))
    {
      return -1;
    }
    if (menu->type < MENU_MAX)
    {
      mutt_str_replace(&SearchBuffers[menu->type], buf);
      search_buf = SearchBuffers[menu->type];
    }
    menu->search_dir =
        ((op == OP_SEARCH) || (op == OP_SEARCH_NEXT)) ? MUTT_SEARCH_DOWN : MUTT_SEARCH_UP;
  }

  search_dir = (menu->search_dir == MUTT_SEARCH_UP) ? -1 : 1;
  if (op == OP_SEARCH_OPPOSITE)
    search_dir = -search_dir;

  if (search_buf)
  {
    uint16_t flags = mutt_mb_is_lower(search_buf) ? REG_ICASE : 0;
    rc = REG_COMP(&re, search_buf, REG_NOSUB | flags);
  }

  if (rc != 0)
  {
    regerror(rc, &re, buf, sizeof(buf));
    mutt_error("%s", buf);
    return -1;
  }

  rc = menu->current + search_dir;
search_next:
  if (wrap)
    mutt_message(_("Search wrapped to top"));
  while ((rc >= 0) && (rc < menu->max))
  {
    if (menu->search(menu, &re, rc) == 0)
    {
      regfree(&re);
      return rc;
    }

    rc += search_dir;
  }

  const bool c_wrap_search = cs_subset_bool(menu->sub, "wrap_search");
  if (c_wrap_search && (wrap++ == 0))
  {
    rc = (search_dir == 1) ? 0 : menu->max - 1;
    goto search_next;
  }
  regfree(&re);
  mutt_error(_("Not found"));
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_dialog_translate_op()

static int menu_dialog_translate_op ( int  i )

static

Convert menubar movement to scrolling.

Parameters

i	Action requested, e.g. OP_NEXT_ENTRY

Return values

num	Action to perform, e.g. OP_NEXT_LINE

Definition at line 218 of file menu.c.

{
  switch (i)
  {
    case OP_NEXT_ENTRY:
      return OP_NEXT_LINE;
    case OP_PREV_ENTRY:
      return OP_PREV_LINE;
    case OP_CURRENT_TOP:
    case OP_FIRST_ENTRY:
      return OP_TOP_PAGE;
    case OP_CURRENT_BOTTOM:
    case OP_LAST_ENTRY:
      return OP_BOTTOM_PAGE;
    case OP_CURRENT_MIDDLE:
      return OP_MIDDLE_PAGE;
  }

  return i;
}

Here is the caller graph for this function:

menu_dialog_dokey()

static int menu_dialog_dokey ( struct Menu *  menu, int *  ip  )

static

Check if there are any menu key events to process.

Parameters

menu	Current Menu
ip	KeyEvent ID

Return values

0	An event occurred for the menu, or a timeout
-1	There was an event, but not for menu

Definition at line 246 of file menu.c.

{
  struct KeyEvent ch;
  char *p = NULL;

  do
  {
    ch = mutt_getch();
  } while (ch.ch == -2); // Timeout

  if (ch.ch < 0)
  {
    *ip = -1;
    return 0;
  }

  if (ch.ch && (p = strchr(menu->keys, ch.ch)))
  {
    *ip = OP_MAX + (p - menu->keys + 1);
    return 0;
  }
  else
  {
    if (ch.op == OP_NULL)
      mutt_unget_event(ch.ch, 0);
    else
      mutt_unget_event(0, ch.op);
    return -1;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_loop()

int 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 282 of file menu.c.

{
  int op = OP_NULL;

  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)
      msgwin_set_text(MT_COLOR_NORMAL, "tag-");

    const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
    const bool c_braille_friendly =
        cs_subset_bool(menu->sub, "braille_friendly");

    /* move the cursor out of the way */
    if (c_arrow_cursor)
      mutt_window_move(menu->win, 2, menu->current - menu->top);
    else if (c_braille_friendly)
      mutt_window_move(menu->win, 0, menu->current - menu->top);
    else
    {
      mutt_window_move(menu->win, menu->win->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;

    const bool c_auto_tag = cs_subset_bool(menu->sub, "auto_tag");
    op = km_dokey(menu->type);
    if ((op == OP_TAG_PREFIX) || (op == OP_TAG_PREFIX_COND))
    {
      if (menu->tagprefix)
      {
        menu->tagprefix = false;
        msgwin_clear_text();
        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_auto_tag)
      menu->tagprefix = true;

    mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);

    if (SigWinch)
    {
      SigWinch = false;
      mutt_resize_screen();
      clearok(stdscr, true); /* force complete redraw */
    }

    if (op < 0)
    {
      if (menu->tagprefix)
        msgwin_clear_text();
      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 */
        {
          int index = search(menu, op);
          if (index != -1)
            menu_set_index(menu, index);
        }
        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_redraw(NULL);
        break;

      case OP_TAG:
        if (menu->tag && ARRAY_EMPTY(&menu->dialog))
        {
          const bool c_resolve = cs_subset_bool(menu->sub, "resolve");

          if (menu->tagprefix && !c_auto_tag)
          {
            for (int i = 0; i < menu->max; i++)
              menu->tagged += menu->tag(menu, i, 0);
            menu->redraw |= MENU_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_set_index(menu, menu->current + 1);
            }
            else
              menu->redraw |= MENU_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 = MENU_REDRAW_FULL;
        break;

      case OP_HELP:
        mutt_help(menu->type);
        menu->redraw = MENU_REDRAW_FULL;
        break;

      case OP_NULL:
        km_error_key(menu->type);
        break;

      case OP_END_COND:
        break;

      default:
        return op;
    }
  }
  /* not reached */
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_get_current_type()

enum MenuType menu_get_current_type

(

void

)

Get the type of the current Window.

Return values

enum	Menu Type, e.g. MENU_PAGER

Definition at line 529 of file menu.c.

{
  struct MuttWindow *win = alldialogs_get_current();
  while (win && win->focus)
    win = win->focus;

  if (!win)
    return MENU_GENERIC;

  if ((win->type == WT_CUSTOM) && (win->parent->type == WT_PAGER))
    return MENU_PAGER;

  if (win->type != WT_MENU)
    return MENU_GENERIC;

  struct Menu *menu = win->wdata;
  if (!menu)
    return MENU_GENERIC;

  return menu->type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_free()

void menu_free

(

struct Menu **

ptr

)

Free a Menu.

Parameters

ptr	Menu to free

Definition at line 555 of file menu.c.

{
  struct Menu *menu = *ptr;

  notify_free(&menu->notify);

  if (menu->mdata_free && menu->mdata)
    menu->mdata_free(menu, &menu->mdata); // Custom function to free private data

  char **line = NULL;
  ARRAY_FOREACH(line, &menu->dialog)
  {
    FREE(line);
  }
  ARRAY_FREE(&menu->dialog);

  FREE(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_new()

struct Menu* menu_new	(	enum MenuType	type,
		struct MuttWindow *	win,
		struct ConfigSubset *	sub
	)

Create a new Menu.

Parameters

type	Menu type, e.g. MENU_ALIAS
win	Parent Window
sub	Config items

Return values

ptr

New Menu

Definition at line 581 of file menu.c.

{
  struct Menu *menu = mutt_mem_calloc(1, sizeof(struct Menu));

  menu->type = type;
  menu->redraw = MENU_REDRAW_FULL;
  menu->color = default_color;
  menu->search = generic_search;
  menu->notify = notify_new();
  menu->win = win;
  menu->pagelen = win->state.rows;
  menu->sub = sub;

  notify_set_parent(menu->notify, win->notify);
  menu_add_observers(menu);

  return menu;
}

Here is the call graph for this function:

Here is the caller graph for this function:

menu_get_index()

int menu_get_index

(

struct Menu *

menu

)

Get the current selection in the Menu.

Parameters

menu

Menu

Return values

num	Index of selection

Definition at line 605 of file menu.c.

{
  if (!menu)
    return -1;

  return menu->current;
}

menu_set_index()

MenuRedrawFlags menu_set_index	(	struct Menu *	menu,
		int	index
	)

Set the current selection in the Menu.

Parameters

menu	Menu
index	Item to select

Return values

num	MenuRedrawFlags, e.g. MENU_REDRAW_INDEX

Definition at line 619 of file menu.c.

{
  return menu_move_selection(menu, index);
}

Here is the call graph for this function:

menu_queue_redraw()

void menu_queue_redraw	(	struct Menu *	menu,
		MenuRedrawFlags	redraw
	)

Queue a request for a redraw.

Parameters

menu	Menu
redraw	Item to redraw, e.g. MENU_REDRAW_CURRENT

Definition at line 629 of file menu.c.

{
  if (!menu)
    return;

  menu->redraw |= redraw;
  menu->win->actions |= WA_RECALC;
}

Variable Documentation

SearchBuffers

char* SearchBuffers[MENU_MAX]

Definition at line 51 of file menu.c.