move.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "gui/lib.h"
#include "lib.h"
 
MenuRedrawFlags menu_set_and_notify(struct Menu *menu, int top, int index)
{
  MenuRedrawFlags flags = MENU_REDRAW_NO_FLAGS;
 
  if (top != menu->top)
  {
    menu->top = top;
    flags |= MENU_REDRAW_FULL;
  }
 
  if (index != menu->current)
  {
    menu->old_current = menu->current;
    menu->current = index;
 
    if (menu->redraw == MENU_REDRAW_NO_FLAGS)
    {
      // If this is the only change
      flags |= MENU_REDRAW_MOTION;
    }
    else
    {
      // otherwise, redraw completely
      flags |= MENU_REDRAW_FULL;
    }
  }
 
  if (flags != MENU_REDRAW_NO_FLAGS)
  {
    menu->redraw |= flags;
    menu->win->actions |= WA_REPAINT;
 
    mutt_debug(LL_NOTIFY, "NT_MENU\n");
    notify_send(menu->notify, NT_MENU, flags, NULL);
  }
  return flags;
}
 
static int menu_drag_view(struct Menu *menu, int top, int index)
{
  if (menu->max <= menu->page_len) // fewer entries than lines
    return 0;
 
  const int page = menu->page_len;
 
  short c_menu_context = cs_subset_number(menu->sub, "menu_context");
  c_menu_context = MIN(c_menu_context, (page / 2));
 
  const bool c_menu_scroll = cs_subset_bool(menu->sub, "menu_scroll");
  if (c_menu_scroll)
  {
    int bottom = top + page;
    // Scroll the view to make the selection visible
    if (index < top + c_menu_context) // scroll=YES, moving UP
      top = index - c_menu_context;
    else if (index >= (bottom - c_menu_context)) // scroll=YES, moving DOWN
      top = index - page + c_menu_context + 1;
  }
  else
  {
    if ((index < top) || (index >= (top + page)))
      top = (index / page) * page; // Round down to a page size
    int bottom = top + page;
 
    // Page up/down to make the selection visible
    if (index < (top + c_menu_context)) // scroll=NO, moving UP
      top = index - page + c_menu_context + 1;
    else if (index >= (bottom - c_menu_context)) // scroll=NO, moving DOWN
      top = index - c_menu_context;
  }
 
  if (top < 0)
    top = 0;
 
  // Tie the last entry to the bottom of the screen
  const bool c_menu_move_off = cs_subset_bool(menu->sub, "menu_move_off");
  if (!c_menu_move_off && (top >= (menu->max - page)))
  {
    top = menu->max - page;
  }
 
  return top;
}
 
static int calc_fit_selection_to_view(struct Menu *menu, int top, int index)
{
  short c_menu_context = cs_subset_number(menu->sub, "menu_context");
  c_menu_context = MIN(c_menu_context, (menu->page_len / 2));
 
  int min = top;
  if (top != 0)
    min += c_menu_context;
 
  int max = top + menu->page_len - 1;
  if (max < (menu->max - 1))
    max -= c_menu_context;
  else
    max = menu->max - 1;
 
  if (index < min)
    index = min;
  else if (index > max)
    index = max;
 
  return index;
}
 
static int calc_move_view(struct Menu *menu, int relative)
{
  if (menu->max <= menu->page_len) // fewer entries than lines
    return 0;
 
  short c_menu_context = cs_subset_number(menu->sub, "menu_context");
  c_menu_context = MIN(c_menu_context, (menu->page_len / 2));
 
  int index = menu->current;
  if (index < c_menu_context)
    return 0;
 
  int top = menu->top + relative;
  if (top < 0)
    return 0;
 
  if ((menu->top + menu->page_len) < menu->max)
    return top;
 
  int max = menu->max - 1;
  const bool c_menu_move_off = cs_subset_bool(menu->sub, "menu_move_off");
  if (c_menu_move_off)
  {
    max -= c_menu_context;
  }
  else
  {
    max -= menu->page_len - 1;
  }
 
  if (top > max)
    top = max;
 
  return top;
}
 
MenuRedrawFlags menu_move_selection(struct Menu *menu, int index)
{
  if (index < 0)
    index = 0;
  else if (index >= menu->max)
    index = menu->max - 1;
 
  int top = menu_drag_view(menu, menu->top, index);
 
  return menu_set_and_notify(menu, top, index);
}
 
MenuRedrawFlags menu_move_view_relative(struct Menu *menu, int relative)
{
  const bool c_menu_move_off = cs_subset_bool(menu->sub, "menu_move_off");
 
  short c_menu_context = cs_subset_number(menu->sub, "menu_context");
  c_menu_context = MIN(c_menu_context, (menu->page_len / 2));
 
  // Move and range-check the view
  int top = menu->top + relative;
  if (top < 0)
  {
    top = 0;
  }
  else if (c_menu_move_off && (top >= (menu->max - c_menu_context)))
  {
    top = menu->max - c_menu_context - 1;
  }
  else if (!c_menu_move_off && ((top + menu->page_len) >= menu->max))
  {
    top = menu->max - menu->page_len;
  }
  if (top < 0)
    top = 0;
 
  // Move the selection on-screen
  int index = menu->current;
  if (index < top)
    index = top;
  else if (index >= (top + menu->page_len))
    index = top + menu->page_len - 1;
 
  // Check for top/bottom limits
  if (index < c_menu_context)
  {
    top = 0;
    index = menu->current;
  }
  else if (!c_menu_move_off && (index > (menu->max - c_menu_context)))
  {
    top = menu->max - menu->page_len;
    index = menu->current;
  }
 
  if (top == menu->top)
  {
    // Can't move the view; move the selection
    index = calc_fit_selection_to_view(menu, top, index + relative);
  }
  else if (index > (top + menu->page_len - c_menu_context - 1))
  {
    index = calc_fit_selection_to_view(menu, top, index + relative);
  }
  else
  {
    // Drag the selection into the view
    index = calc_fit_selection_to_view(menu, top, index);
  }
 
  return menu_set_and_notify(menu, top, index);
}
 
void menu_adjust(struct Menu *menu)
{
  int top = calc_move_view(menu, 0);
  top = menu_drag_view(menu, top, menu->current);
 
  menu_set_and_notify(menu, top, menu->current);
}
 
// These functions move the selection (and may cause the view to move)
MenuRedrawFlags menu_top_page(struct Menu *menu)
{
  return menu_move_selection(menu, menu->top);
}
 
MenuRedrawFlags menu_middle_page(struct Menu *menu)
{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return MENU_REDRAW_NO_FLAGS;
  }
 
  int i = menu->top + menu->page_len;
  if (i > (menu->max - 1))
    i = menu->max - 1;
 
  return menu_move_selection(menu, menu->top + (i - menu->top) / 2);
}
 
MenuRedrawFlags menu_bottom_page(struct Menu *menu)
{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return MENU_REDRAW_NO_FLAGS;
  }
 
  int index = menu->top + menu->page_len - 1;
  if (index > (menu->max - 1))
    index = menu->max - 1;
  return menu_move_selection(menu, index);
}
 
MenuRedrawFlags menu_prev_entry(struct Menu *menu)
{
  if (menu->current > 0)
    return menu_move_selection(menu, menu->current - 1);
 
  mutt_message(_("You are on the first entry"));
  return MENU_REDRAW_NO_FLAGS;
}
 
MenuRedrawFlags menu_next_entry(struct Menu *menu)
{
  if (menu->current < (menu->max - 1))
    return menu_move_selection(menu, menu->current + 1);
 
  mutt_message(_("You are on the last entry"));
  return MENU_REDRAW_NO_FLAGS;
}
 
MenuRedrawFlags menu_first_entry(struct Menu *menu)
{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return MENU_REDRAW_NO_FLAGS;
  }
 
  return menu_move_selection(menu, 0);
}
 
MenuRedrawFlags menu_last_entry(struct Menu *menu)
{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return MENU_REDRAW_NO_FLAGS;
  }
 
  return menu_move_selection(menu, menu->max - 1);
}
 
// These functions move the view (and may cause the selection to move)
MenuRedrawFlags menu_current_top(struct Menu *menu)
{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return MENU_REDRAW_NO_FLAGS;
  }
 
  short c_menu_context = cs_subset_number(menu->sub, "menu_context");
  if (c_menu_context > (menu->page_len / 2))
    return MENU_REDRAW_NO_FLAGS;
 
  c_menu_context = MIN(c_menu_context, (menu->page_len / 2));
  return menu_move_view_relative(menu, menu->current - menu->top - c_menu_context);
}
 
MenuRedrawFlags menu_current_middle(struct Menu *menu)
{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return MENU_REDRAW_NO_FLAGS;
  }
 
  short c_menu_context = cs_subset_number(menu->sub, "menu_context");
  if (c_menu_context > (menu->page_len / 2))
    return MENU_REDRAW_NO_FLAGS;
 
  return menu_move_view_relative(menu, menu->current - (menu->top + (menu->page_len / 2)));
}
 
MenuRedrawFlags menu_current_bottom(struct Menu *menu)
{
  if (menu->max == 0)
  {
    mutt_error(_("No entries"));
    return MENU_REDRAW_NO_FLAGS;
  }
 
  short c_menu_context = cs_subset_number(menu->sub, "menu_context");
  if (c_menu_context > (menu->page_len / 2))
    return MENU_REDRAW_NO_FLAGS;
 
  c_menu_context = MIN(c_menu_context, (menu->page_len / 2));
  return menu_move_view_relative(menu, 0 - (menu->top + menu->page_len - 1 -
                                            menu->current - c_menu_context));
}
 
MenuRedrawFlags menu_half_up(struct Menu *menu)
{
  return menu_move_view_relative(menu, 0 - (menu->page_len / 2));
}
 
MenuRedrawFlags menu_half_down(struct Menu *menu)
{
  return menu_move_view_relative(menu, (menu->page_len / 2));
}
 
MenuRedrawFlags menu_prev_line(struct Menu *menu)
{
  MenuRedrawFlags flags = menu_move_view_relative(menu, -1);
  if (flags == MENU_REDRAW_NO_FLAGS)
    mutt_message(_("You can't scroll up farther"));
  return flags;
}
 
MenuRedrawFlags menu_next_line(struct Menu *menu)
{
  MenuRedrawFlags flags = menu_move_view_relative(menu, 1);
  if (flags == MENU_REDRAW_NO_FLAGS)
    mutt_message(_("You can't scroll down farther"));
  return flags;
}
 
MenuRedrawFlags menu_prev_page(struct Menu *menu)
{
  return menu_move_view_relative(menu, 0 - menu->page_len);
}
 
MenuRedrawFlags menu_next_page(struct Menu *menu)
{
  return menu_move_view_relative(menu, menu->page_len);
}